misarpost 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ed242bb7e51c5f0dc6ca950f1c79d10cbef43efd93da2eb8b5650f9418a7499d
+  data.tar.gz: daec82825bf4f1e66fdc557ec61c5994a4e71b029444b139ca58cfb951b1ccf0
+SHA512:
+  metadata.gz: 48709887643f1f548d4f9bc4183de0a4558cdfcff761e473923820a735d0876161d24b48f7ddadb19f790acd237e6e6b80a6ee8ef8142c00a6962ce7c033bb36
+  data.tar.gz: 1f140c8d6ef3bc78d8f4500dc2772617c0efe0cd23d16e60ee27fbeae41bfddc5c6206cba62ef89a831ecf7f58b92a91dd2f48604074690fb4158ff3072f2881

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this SDK are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] — 2026-10-16
+
+First release of `misarpost (RubyGems)`.
+
+- Every key-authenticated MisarPost endpoint, generated from `sdks/manifest.json` —
+  the same surface in all twelve MisarPost SDKs and the CLI.
+- Canonical base URL `https://api.misar.io/post` (also served at `https://post.misar.io/api`).
+- Plan refusals (`code: "plan_limit_exceeded"`, HTTP 402) surface as a typed plan-limit
+  error carrying the server's upgrade offer; detected by code before the status and never retried.
+- Retries for throttles, 5xx and network failures with `Retry-After` support.
+- Pagination helper for `?page=` list endpoints and `X-MisarPost-Signature` webhook verification.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Misar.AI
+
+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,250 @@
+# MisarPost Ruby SDK
+
+> Schedule, publish, generate and analyze social content from Ruby — standard library only.
+
+[![Gem](https://img.shields.io/gem/v/misarpost)](https://rubygems.org/gems/misarpost)
+[![license](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
+
+**17 resource groups · 102 methods · zero runtime dependencies**
+
+MisarPost is the AI social command center: publish to X, LinkedIn, Instagram, Threads, Bluesky, TikTok and more from one API, repurpose long-form content with ContentRipple, research trends with TrendPulse and write in your own voice with PersonaForge.
+
+The resource layer is generated from the API's own route tree, so it always matches the server. Ruby 2.6+, `Net::HTTP` under the hood.
+
+---
+
+## Install
+
+### Bundler
+
+```ruby
+gem "misarpost"
+```
+
+### gem
+
+```bash
+gem install misarpost
+```
+
+---
+
+## Authentication
+
+Create an API key at https://post.misar.io/dashboard/api-keys. It starts with `mpk_` and is
+sent as `Authorization: Bearer mpk_…`. Each key carries scopes (`posts:read`,
+`schedule:write`, `generate:write`, …); a call outside them answers **403** with
+`code: "insufficient_scope"`. New keys get every scope unless you narrow them.
+
+```ruby
+require "misarpost"
+
+post = MisarPost::Client.new(ENV.fetch("MISARPOST_API_KEY"))
+```
+
+---
+
+## Resources
+
+| Resource | Methods | Scopes |
+| --- | --- | --- |
+| `post.analytics` | `stats`, `trends` | `analytics:read` |
+| `post.composer` | `discord_channels`, `hashnode_publications`, `hashnode_tags`, `lemmy_communities`, `listmonk_lists`, `listmonk_templates`, `medium_publications`, `pinterest_boards`, `reddit_flairs`, `skool_groups`, `slack_channels`, `whop_forums` | `connections:read` |
+| `post.connections` | `list`, `plugs`, `update_plugs`, `wordpress_taxonomies` | `connections:read`, `connections:write` |
+| `post.contentripple` | `delete_history`, `feed`, `history`, `parse`, `repurpose`, `schedule`, `update_variants`, `usage` | `posts:write`, `generate:write`, `posts:read`, `schedule:write` |
+| `post.drafts` | `create`, `list` | `posts:write`, `posts:read` |
+| `post.generate` | `create`, `enhance`, `hashtags`, `image`, `optimize`, `plan` | `generate:write` |
+| `post.growth` | `next_opportunity`, `opportunities`, `overview`, `playbooks` | `analytics:read` |
+| `post.media` | `delete`, `list` | `media:write`, `media:read` |
+| `post.notifications` | `list`, `read_all`, `update` | `notifications:read`, `notifications:write` |
+| `post.personaforge` | `approve_replies`, `bio`, `create_competitors`, `create_persona`, `create_replies`, `create_voice`, `delete_persona`, `generate`, `get_persona`, `get_voice`, `list_competitors`, `list_personas`, `list_replies`, `persona_status`, `update_persona` | `personas:write`, `generate:write`, `personas:read` |
+| `post.posts` | `calendar`, `cancel`, `delete`, `list`, `reply`, `revert`, `revert_batch`, `schedule`, `share`, `unshare`, `update` | `posts:read`, `posts:write`, `schedule:write` |
+| `post.post_tags` | `create`, `delete`, `list`, `update` | `posts:write`, `posts:read` |
+| `post.post_templates` | `create`, `delete`, `get`, `list`, `update` | `posts:write`, `posts:read` |
+| `post.trendpulse` | `create_platform_content`, `digest`, `fetch`, `hooks`, `list`, `list_platform_content`, `performance`, `pipeline`, `refresh`, `use_platform_content` | `trends:write`, `trends:read`, `analytics:read`, `schedule:write` |
+| `post.video` | `avatars`, `generate`, `script`, `status`, `voices` | `media:read`, `generate:write` |
+| `post.webhooks` | `create_outbound`, `delete_outbound`, `list_outbound`, `update_outbound` | `webhooks:write`, `webhooks:read` |
+| `post.workspaces` | `add_member`, `create`, `list`, `members`, `remove_member` | `workspaces:write`, `workspaces:read` |
+
+Methods take path parameters positionally, then `body` (a Hash, when the endpoint reads one), then `query:`.
+
+---
+
+## Client
+
+| Thing | Detail |
+| --- | --- |
+| Entry point | `MisarPost::Client.new(api_key, base_url:, max_retries: 3, timeout: 30, http: adapter)` |
+| `base_url` | `https://api.misar.io/post` (also served at `https://post.misar.io/api`) |
+| Transport | `Net::HTTP`; inject any `#call(method, uri, headers, body, timeout)` adapter with `http:`. |
+| Retried | `429` throttles, `500`, `502`, `503`, `504` and network failures — exponential backoff from 200 ms honouring `Retry-After`. |
+| Never retried | Plan refusals (`MisarPost::PlanLimitError`). |
+| Errors | `MisarPost::Error`, `MisarPost::NetworkError`, `MisarPost::PlanLimitError` |
+| Also exported | `MisarPost.paginate`, `MisarPost.verify_webhook_signature` |
+
+---
+
+## Quick start
+
+```ruby
+post = MisarPost::Client.new("mpk_your_key")
+
+accounts = post.connections.list["accounts"]
+post.generate.create("prompt" => "Announce our v2 launch", "platforms" => ["linkedin"])
+post.posts.schedule(
+  "accountIds" => [accounts.first["id"]],
+  "content" => "We just shipped v2",
+  "scheduledAt" => "2026-11-01T09:00:00Z"
+)
+```
+
+## Pagination
+
+```ruby
+MisarPost.paginate { |n| post.posts.list(query: { "status" => "queued", "page" => n }) }.each do |page|
+  page["posts"].each { |p| puts p["id"] }
+end
+```
+
+## Plan limits
+
+When a monthly allowance is spent, or a feature is not on the plan, the API answers
+**402** with `code: "plan_limit_exceeded"` and an `upgrade` offer. The SDK detects the
+code before it looks at the status, raises `MisarPost::PlanLimitError`, and **never retries
+it**. All copy comes from the server.
+
+```ruby
+begin
+  post.generate.enhance("content" => "…")
+rescue MisarPost::PlanLimitError => e
+  puts e.offer["headline"], e.offer["cta"]
+  puts "Upgrade: #{e.upgrade_url} (resets in #{e.retry_after}s)"
+end
+```
+
+## Webhooks
+
+```ruby
+ok = MisarPost.verify_webhook_signature(secret, request.raw_post, request.headers["X-MisarPost-Signature"])
+```
+
+## Method reference
+
+| Call | HTTP | Scope |
+| --- | --- | --- |
+| `post.analytics.stats` | `GET /stats` | `analytics:read` |
+| `post.analytics.trends` | `GET /analytics/trends` | `analytics:read` |
+| `post.composer.discord_channels` | `GET /composer/discord/channels` | `connections:read` |
+| `post.composer.hashnode_publications` | `GET /composer/hashnode/publications` | `connections:read` |
+| `post.composer.hashnode_tags` | `GET /composer/hashnode/tags` | `connections:read` |
+| `post.composer.lemmy_communities` | `GET /composer/lemmy/communities` | `connections:read` |
+| `post.composer.listmonk_lists` | `GET /composer/listmonk/lists` | `connections:read` |
+| `post.composer.listmonk_templates` | `GET /composer/listmonk/templates` | `connections:read` |
+| `post.composer.medium_publications` | `GET /composer/medium/publications` | `connections:read` |
+| `post.composer.pinterest_boards` | `GET /composer/pinterest/boards` | `connections:read` |
+| `post.composer.reddit_flairs` | `GET /composer/reddit/flairs` | `connections:read` |
+| `post.composer.skool_groups` | `GET /composer/skool/groups` | `connections:read` |
+| `post.composer.slack_channels` | `GET /composer/slack/channels` | `connections:read` |
+| `post.composer.whop_forums` | `GET /composer/whop/forums` | `connections:read` |
+| `post.connections.list` | `GET /connections` | `connections:read` |
+| `post.connections.plugs` | `GET /connections/:accountId/plugs` | `connections:read` |
+| `post.connections.update_plugs` | `PATCH /connections/:accountId/plugs` | `connections:write` |
+| `post.connections.wordpress_taxonomies` | `GET /connections/:accountId/wordpress-taxonomies` | `connections:read` |
+| `post.contentripple.delete_history` | `DELETE /contentripple/history` | `posts:write` |
+| `post.contentripple.feed` | `POST /contentripple/feed` | `generate:write` |
+| `post.contentripple.history` | `GET /contentripple/history` | `posts:read` |
+| `post.contentripple.parse` | `POST /contentripple/parse` | `generate:write` |
+| `post.contentripple.repurpose` | `POST /contentripple` | `generate:write` |
+| `post.contentripple.schedule` | `POST /contentripple/schedule` | `schedule:write` |
+| `post.contentripple.update_variants` | `PATCH /contentripple/variants` | `posts:write` |
+| `post.contentripple.usage` | `GET /contentripple` | `posts:read` |
+| `post.drafts.create` | `POST /drafts` | `posts:write` |
+| `post.drafts.list` | `GET /drafts` | `posts:read` |
+| `post.generate.create` | `POST /generate` | `generate:write` |
+| `post.generate.enhance` | `POST /generate/enhance` | `generate:write` |
+| `post.generate.hashtags` | `POST /generate/hashtags` | `generate:write` |
+| `post.generate.image` | `POST /generate/image` | `generate:write` |
+| `post.generate.optimize` | `GET /generate/optimize` | `generate:write` |
+| `post.generate.plan` | `POST /generate/plan` | `generate:write` |
+| `post.growth.next_opportunity` | `GET /growth/next-opportunity` | `analytics:read` |
+| `post.growth.opportunities` | `GET /growth/opportunities` | `analytics:read` |
+| `post.growth.overview` | `GET /growth/overview` | `analytics:read` |
+| `post.growth.playbooks` | `GET /growth/playbooks` | `analytics:read` |
+| `post.media.delete` | `DELETE /media/:id` | `media:write` |
+| `post.media.list` | `GET /media` | `media:read` |
+| `post.notifications.list` | `GET /notifications` | `notifications:read` |
+| `post.notifications.read_all` | `POST /notifications/read-all` | `notifications:write` |
+| `post.notifications.update` | `PATCH /notifications/:id` | `notifications:write` |
+| `post.personaforge.approve_replies` | `POST /personaforge/replies/approve` | `personas:write` |
+| `post.personaforge.bio` | `POST /personaforge/bio` | `generate:write` |
+| `post.personaforge.create_competitors` | `POST /personaforge/competitors` | `personas:write` |
+| `post.personaforge.create_persona` | `POST /personaforge/personas` | `personas:write` |
+| `post.personaforge.create_replies` | `POST /personaforge/replies` | `personas:write` |
+| `post.personaforge.create_voice` | `POST /personaforge/voice` | `personas:write` |
+| `post.personaforge.delete_persona` | `DELETE /personaforge/personas/:id` | `personas:write` |
+| `post.personaforge.generate` | `POST /personaforge/generate` | `generate:write` |
+| `post.personaforge.get_persona` | `GET /personaforge/personas/:id` | `personas:read` |
+| `post.personaforge.get_voice` | `GET /personaforge/voice` | `personas:read` |
+| `post.personaforge.list_competitors` | `GET /personaforge/competitors` | `personas:read` |
+| `post.personaforge.list_personas` | `GET /personaforge/personas` | `personas:read` |
+| `post.personaforge.list_replies` | `GET /personaforge/replies` | `personas:read` |
+| `post.personaforge.persona_status` | `GET /personaforge/personas/status/:jobId` | `personas:read` |
+| `post.personaforge.update_persona` | `PATCH /personaforge/personas/:id` | `personas:write` |
+| `post.posts.calendar` | `GET /calendar` | `posts:read` |
+| `post.posts.cancel` | `DELETE /posts` | `posts:write` |
+| `post.posts.delete` | `DELETE /posts/:id` | `posts:write` |
+| `post.posts.list` | `GET /posts` | `posts:read` |
+| `post.posts.reply` | `POST /posts/:id/reply` | `posts:write` |
+| `post.posts.revert` | `POST /posts/:id/revert` | `posts:write` |
+| `post.posts.revert_batch` | `POST /posts/revert-batch` | `posts:write` |
+| `post.posts.schedule` | `POST /schedule` | `schedule:write` |
+| `post.posts.share` | `POST /posts/:id/share` | `posts:write` |
+| `post.posts.unshare` | `DELETE /posts/:id/share` | `posts:write` |
+| `post.posts.update` | `PATCH /posts/:id` | `posts:write` |
+| `post.post_tags.create` | `POST /post-tags` | `posts:write` |
+| `post.post_tags.delete` | `DELETE /post-tags/:id` | `posts:write` |
+| `post.post_tags.list` | `GET /post-tags` | `posts:read` |
+| `post.post_tags.update` | `PATCH /post-tags/:id` | `posts:write` |
+| `post.post_templates.create` | `POST /post-templates` | `posts:write` |
+| `post.post_templates.delete` | `DELETE /post-templates/:id` | `posts:write` |
+| `post.post_templates.get` | `GET /post-templates/:id` | `posts:read` |
+| `post.post_templates.list` | `GET /post-templates` | `posts:read` |
+| `post.post_templates.update` | `PATCH /post-templates/:id` | `posts:write` |
+| `post.trendpulse.create_platform_content` | `POST /trendpulse/platform-content` | `trends:write` |
+| `post.trendpulse.digest` | `POST /trendpulse/digest` | `trends:write` |
+| `post.trendpulse.fetch` | `POST /trendpulse/fetch` | `trends:write` |
+| `post.trendpulse.hooks` | `GET /trendpulse/hooks` | `trends:read` |
+| `post.trendpulse.list` | `GET /trendpulse` | `trends:read` |
+| `post.trendpulse.list_platform_content` | `GET /trendpulse/platform-content` | `trends:read` |
+| `post.trendpulse.performance` | `GET /trendpulse/performance` | `analytics:read` |
+| `post.trendpulse.pipeline` | `POST /trendpulse/pipeline` | `schedule:write` |
+| `post.trendpulse.refresh` | `POST /trendpulse` | `trends:write` |
+| `post.trendpulse.use_platform_content` | `POST /trendpulse/platform-content/use` | `trends:write` |
+| `post.video.avatars` | `GET /video/avatars` | `media:read` |
+| `post.video.generate` | `POST /video/generate` | `generate:write` |
+| `post.video.script` | `POST /video/script` | `generate:write` |
+| `post.video.status` | `GET /video/status/:jobId` | `media:read` |
+| `post.video.voices` | `GET /video/voices` | `media:read` |
+| `post.webhooks.create_outbound` | `POST /webhooks/outbound` | `webhooks:write` |
+| `post.webhooks.delete_outbound` | `DELETE /webhooks/outbound/:id` | `webhooks:write` |
+| `post.webhooks.list_outbound` | `GET /webhooks/outbound` | `webhooks:read` |
+| `post.webhooks.update_outbound` | `PATCH /webhooks/outbound/:id` | `webhooks:write` |
+| `post.workspaces.add_member` | `POST /workspaces/:id/members` | `workspaces:write` |
+| `post.workspaces.create` | `POST /workspaces` | `workspaces:write` |
+| `post.workspaces.list` | `GET /workspaces` | `workspaces:read` |
+| `post.workspaces.members` | `GET /workspaces/:id/members` | `workspaces:read` |
+| `post.workspaces.remove_member` | `DELETE /workspaces/:id/members` | `workspaces:write` |
+
+---
+
+## Links
+
+- Website — https://www.misarpost.com
+- App — https://post.misar.io
+- Parent — https://misar.io
+- Documentation — https://docs.misar.io/post
+- API reference — https://api.misar.io/post/openapi.json
+- Source — https://github.com/Misar-AI/misarpost-sdks
+- RubyGems — https://rubygems.org/gems/misarpost
+
+MIT © [Misar.AI](https://misar.io)

data/lib/misarpost/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MisarPost
+  # MisarPost API client.
+  #
+  #   post = MisarPost::Client.new(ENV.fetch("MISARPOST_API_KEY"))
+  #   post.posts.list(query: { "status" => "queued" })
+  #
+  # Every resource and method is generated from the API's own route tree
+  # (sdks/manifest.json).
+  class Client < Generated::Resources
+    attr_reader :transport
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, max_retries: 3, timeout: 30, http: nil, sleeper: nil)
+      @transport = Transport.new(api_key, base_url: base_url, max_retries: max_retries,
+                                          timeout: timeout, http: http, sleeper: sleeper)
+      super(@transport)
+    end
+
+    def base_url
+      @transport.base_url
+    end
+  end
+end

data/lib/misarpost/core/pagination.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MisarPost
+  # Page through MisarPost's ?page= list endpoints. Yields page 1, 2, … until
+  # the response's totalPages is reached, or — when an endpoint reports no
+  # totals — until a page comes back empty.
+  #
+  #   MisarPost.paginate { |n| post.posts.list(query: { "status" => "queued", "page" => n }) }.each { |page| ... }
+  def self.paginate(start_page: 1, max_pages: nil, &fetch_page)
+    Enumerator.new do |yielder|
+      page_no = start_page
+      seen = 0
+      loop do
+        break if max_pages && seen >= max_pages
+        result = fetch_page.call(page_no)
+        yielder << result
+        total = result.is_a?(Hash) ? result["totalPages"] : nil
+        if total.is_a?(Integer)
+          break if page_no >= total
+        else
+          items = result.is_a?(Hash) ? result.values.find { |v| v.is_a?(Array) } : nil
+          break if items.nil? || items.empty?
+        end
+        page_no += 1
+        seen += 1
+      end
+    end
+  end
+end

data/lib/misarpost/core/transport.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "erb"
+
+module MisarPost
+  SDK_VERSION = "1.0.0"
+  DEFAULT_BASE_URL = "https://api.misar.io/post"
+
+  # Default HTTP adapter over Net::HTTP. Any object responding to
+  # call(method, uri, headers, body, timeout) -> [status, headers_hash, body_string]
+  # can replace it (tests inject a fake).
+  class NetHttpAdapter
+    def call(method, uri, headers, body, timeout)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      klass = Net::HTTP.const_get(method.capitalize)
+      request = klass.new(uri.request_uri, headers)
+      request.body = body if body
+      response = http.request(request)
+      hdrs = {}
+      response.each_header { |k, v| hdrs[k.downcase] = v }
+      [response.code.to_i, hdrs, response.body.to_s]
+    end
+  end
+
+  # HTTP transport the generated resource layer is written against. One
+  # credential, one path in: the account API key (mpk_…) as a bearer token.
+  class Transport
+    RETRYABLE = [429, 500, 502, 503, 504].freeze
+
+    attr_reader :base_url
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, max_retries: 3, timeout: 30, http: nil, sleeper: nil)
+      if api_key.nil? || api_key.empty?
+        raise ArgumentError, "A MisarPost API key is required. Create one at " \
+                             "https://post.misar.io/dashboard/api-keys (it starts with mpk_)."
+      end
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/+\z}, "")
+      @max_retries = [max_retries, 1].max
+      @timeout = timeout
+      @http = http || NetHttpAdapter.new
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+    end
+
+    def self.enc(value)
+      ERB::Util.url_encode(value.to_s)
+    end
+
+    # The JSON body of a call. Ruby 3 binds a brace-less trailing hash
+    # (+update(id, "contentText" => "x")+) to keyword arguments, not to the
+    # positional +body+, so every body method also takes +**fields+ and they
+    # land here. Both spellings, and +update(id, contentText: "x")+, therefore
+    # send the same body.
+    def self.body(body, fields)
+      return body if fields.empty?
+      unless body.nil? || body.is_a?(Hash)
+        raise ArgumentError, "pass the request body as one Hash or as keyword fields, not both"
+      end
+
+      (body || {}).transform_keys(&:to_s).merge(fields.transform_keys(&:to_s))
+    end
+
+    def request(method, path, query: nil, body: nil)
+      uri = URI("#{@base_url}#{path}#{build_query(query)}")
+      headers = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json",
+        "User-Agent" => "misarpost-ruby/#{SDK_VERSION}"
+      }
+      payload = nil
+      unless body.nil?
+        headers["Content-Type"] = "application/json"
+        payload = JSON.generate(body)
+      end
+
+      attempt = 0
+      loop do
+        begin
+          status, resp_headers, raw = @http.call(method, uri, headers, payload, @timeout)
+        rescue StandardError => e
+          raise if e.is_a?(MisarPost::Error)
+          if attempt + 1 < @max_retries
+            @sleeper.call(backoff(attempt, nil))
+            attempt += 1
+            next
+          end
+          raise NetworkError.new(e.message, e)
+        end
+
+        data = decode(raw)
+        return normalize(data) if status >= 200 && status < 300
+
+        # Plan refusals first, by code — never retried.
+        if MisarPost.plan_limit_body?(data)
+          message = data["error"] || (data["upgrade"] || {})["headline"] || "Plan limit exceeded"
+          raise PlanLimitError.new(status, message, data, resp_headers)
+        end
+
+        if RETRYABLE.include?(status) && attempt + 1 < @max_retries
+          @sleeper.call(backoff(attempt, resp_headers))
+          attempt += 1
+          next
+        end
+
+        body_hash = data.is_a?(Hash) ? data : {}
+        message = body_hash["error"] || body_hash["message"] || (data.is_a?(String) && !data.empty? ? data : "HTTP #{status}")
+        raise Error.new(status, message.to_s, (body_hash["code"] || "api_error").to_s, data)
+      end
+    end
+
+    private
+
+    def build_query(query)
+      return "" if query.nil? || query.empty?
+      pairs = []
+      query.each do |k, v|
+        next if v.nil?
+        Array(v).each { |item| pairs << [k.to_s, item.to_s] }
+      end
+      pairs.empty? ? "" : "?#{URI.encode_www_form(pairs)}"
+    end
+
+    # Exponential backoff from 200 ms, honouring Retry-After (capped at 60 s).
+    def backoff(attempt, headers)
+      retry_after = headers && headers["retry-after"]
+      return [retry_after.to_f, 60.0].min if retry_after.to_s =~ /\A\d+(\.\d+)?\z/
+      0.2 * (2**attempt)
+    end
+
+    def decode(raw)
+      return nil if raw.nil? || raw.empty?
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+
+    def normalize(data)
+      return {} if data.nil?
+      data.is_a?(Hash) ? data : { "data" => data }
+    end
+  end
+end

data/lib/misarpost/core/webhooks.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module MisarPost
+  # Outbound webhook deliveries carry X-MisarPost-Signature: sha256=<hex> — the
+  # HMAC-SHA256 of the RAW request body keyed with the endpoint's mpwh_ secret.
+  WEBHOOK_SIGNATURE_HEADER = "X-MisarPost-Signature"
+
+  def self.compute_webhook_signature(secret, raw_body)
+    "sha256=" + OpenSSL::HMAC.hexdigest("SHA256", secret, raw_body)
+  end
+
+  def self.verify_webhook_signature(secret, raw_body, signature_header)
+    return false if secret.nil? || secret.empty? || signature_header.nil?
+    expected = compute_webhook_signature(secret, raw_body)
+    given = signature_header.strip.downcase
+    return false unless expected.bytesize == given.bytesize
+    diff = 0
+    expected.bytes.zip(given.bytes) { |a, b| diff |= a ^ b }
+    diff.zero?
+  end
+end

data/lib/misarpost/errors.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MisarPost
+  # Any non-2xx answer from the MisarPost API.
+  class Error < StandardError
+    attr_reader :status, :code, :body
+
+    def initialize(status, message, code = "api_error", body = nil)
+      @status = status
+      @code = code
+      @body = body
+      super("misarpost: API error #{status} (#{code}): #{message}")
+    end
+
+    # The key was rejected outright: missing, revoked, expired, or another product's.
+    def unauthorized?
+      status == 401
+    end
+
+    # The key is valid but lacks the scope this endpoint requires.
+    def forbidden?
+      status == 403
+    end
+
+    def retryable?
+      status == 429 || (status >= 500 && status < 600)
+    end
+  end
+
+  class NetworkError < Error
+    attr_reader :cause_error
+
+    def initialize(message, cause_error = nil)
+      @cause_error = cause_error
+      super(0, message, "network_error")
+    end
+  end
+
+  # The plan behind the API key blocks this call: HTTP 402 with
+  # code "plan_limit_exceeded" and an upgrade offer. Never retried.
+  class PlanLimitError < Error
+    attr_reader :offer, :plan, :upgrade_url, :retry_after, :feature
+
+    def initialize(status, message, body = nil, headers = {})
+      h = (headers || {}).each_with_object({}) { |(k, v), acc| acc[k.to_s.downcase] = v }
+      data = body.is_a?(Hash) ? body : {}
+      @offer = data["upgrade"].is_a?(Hash) ? data["upgrade"] : nil
+      offer = @offer || {}
+      @plan = h["x-misar-plan"] || (offer["current_plan"] || {})["slug"]
+      @upgrade_url = h["x-misar-upgrade-url"] || (offer["urls"] || {})["pricing"]
+      retry_after = h["retry-after"].to_s
+      @retry_after = retry_after =~ /\A\d+\z/ ? retry_after.to_i : nil
+      @feature = offer["feature"]
+      super(status, message, "plan_limit_exceeded", body)
+    end
+  end
+
+  # True when an error body carries the API's plan-refusal marker.
+  def self.plan_limit_body?(data)
+    data.is_a?(Hash) && (data["code"] == "plan_limit_exceeded" || data["upgrade"].is_a?(Hash))
+  end
+end

data/lib/misarpost/generated/resources.rb

@@ -0,0 +1,663 @@
+# AUTO-GENERATED by scripts/generate-sdks.mjs from sdks/manifest.json.
+# Do not edit by hand — changes are overwritten. To change this surface,
+# change the API route, re-run scripts/sync-sdk-manifest.mjs, then
+# re-run scripts/generate-sdks.mjs.
+# frozen_string_literal: true
+
+module MisarPost
+  module Generated
+    # The `analytics` resource group.
+    class AnalyticsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /stats (scope: analytics:read)
+      def stats(query: nil)
+        @transport.request("GET", "/stats", query: query)
+      end
+
+      # GET /analytics/trends (scope: analytics:read)
+      def trends(query: nil)
+        @transport.request("GET", "/analytics/trends", query: query)
+      end
+    end
+
+    # The `composer` resource group.
+    class ComposerResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /composer/discord/channels (scope: connections:read)
+      def discord_channels(query: nil)
+        @transport.request("GET", "/composer/discord/channels", query: query)
+      end
+
+      # GET /composer/hashnode/publications (scope: connections:read)
+      def hashnode_publications(query: nil)
+        @transport.request("GET", "/composer/hashnode/publications", query: query)
+      end
+
+      # GET /composer/hashnode/tags (scope: connections:read)
+      def hashnode_tags(query: nil)
+        @transport.request("GET", "/composer/hashnode/tags", query: query)
+      end
+
+      # GET /composer/lemmy/communities (scope: connections:read)
+      def lemmy_communities(query: nil)
+        @transport.request("GET", "/composer/lemmy/communities", query: query)
+      end
+
+      # GET /composer/listmonk/lists (scope: connections:read)
+      def listmonk_lists(query: nil)
+        @transport.request("GET", "/composer/listmonk/lists", query: query)
+      end
+
+      # GET /composer/listmonk/templates (scope: connections:read)
+      def listmonk_templates(query: nil)
+        @transport.request("GET", "/composer/listmonk/templates", query: query)
+      end
+
+      # GET /composer/medium/publications (scope: connections:read)
+      def medium_publications(query: nil)
+        @transport.request("GET", "/composer/medium/publications", query: query)
+      end
+
+      # GET /composer/pinterest/boards (scope: connections:read)
+      def pinterest_boards(query: nil)
+        @transport.request("GET", "/composer/pinterest/boards", query: query)
+      end
+
+      # GET /composer/reddit/flairs (scope: connections:read)
+      def reddit_flairs(query: nil)
+        @transport.request("GET", "/composer/reddit/flairs", query: query)
+      end
+
+      # GET /composer/skool/groups (scope: connections:read)
+      def skool_groups(query: nil)
+        @transport.request("GET", "/composer/skool/groups", query: query)
+      end
+
+      # GET /composer/slack/channels (scope: connections:read)
+      def slack_channels(query: nil)
+        @transport.request("GET", "/composer/slack/channels", query: query)
+      end
+
+      # GET /composer/whop/forums (scope: connections:read)
+      def whop_forums(query: nil)
+        @transport.request("GET", "/composer/whop/forums", query: query)
+      end
+    end
+
+    # The `connections` resource group.
+    class ConnectionsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /connections (scope: connections:read)
+      def list(query: nil)
+        @transport.request("GET", "/connections", query: query)
+      end
+
+      # GET /connections/:accountId/plugs (scope: connections:read)
+      def plugs(account_id, query: nil)
+        @transport.request("GET", "/connections/#{Transport.enc(account_id)}/plugs", query: query)
+      end
+
+      # PATCH /connections/:accountId/plugs (scope: connections:write)
+      def update_plugs(account_id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/connections/#{Transport.enc(account_id)}/plugs", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /connections/:accountId/wordpress-taxonomies (scope: connections:read)
+      def wordpress_taxonomies(account_id, query: nil)
+        @transport.request("GET", "/connections/#{Transport.enc(account_id)}/wordpress-taxonomies", query: query)
+      end
+    end
+
+    # The `contentripple` resource group.
+    class ContentrippleResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # DELETE /contentripple/history (scope: posts:write)
+      def delete_history(body = {}, query: nil, **fields)
+        @transport.request("DELETE", "/contentripple/history", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /contentripple/feed (scope: generate:write)
+      def feed(body = {}, query: nil, **fields)
+        @transport.request("POST", "/contentripple/feed", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /contentripple/history (scope: posts:read)
+      def history(query: nil)
+        @transport.request("GET", "/contentripple/history", query: query)
+      end
+
+      # POST /contentripple/parse (scope: generate:write)
+      def parse(body = {}, query: nil, **fields)
+        @transport.request("POST", "/contentripple/parse", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /contentripple (scope: generate:write)
+      def repurpose(body = {}, query: nil, **fields)
+        @transport.request("POST", "/contentripple", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /contentripple/schedule (scope: schedule:write)
+      def schedule(body = {}, query: nil, **fields)
+        @transport.request("POST", "/contentripple/schedule", query: query, body: Transport.body(body, fields))
+      end
+
+      # PATCH /contentripple/variants (scope: posts:write)
+      def update_variants(body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/contentripple/variants", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /contentripple (scope: posts:read)
+      def usage(query: nil)
+        @transport.request("GET", "/contentripple", query: query)
+      end
+    end
+
+    # The `drafts` resource group.
+    class DraftsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /drafts (scope: posts:write)
+      def create(body = {}, query: nil, **fields)
+        @transport.request("POST", "/drafts", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /drafts (scope: posts:read)
+      def list(query: nil)
+        @transport.request("GET", "/drafts", query: query)
+      end
+    end
+
+    # The `generate` resource group.
+    class GenerateResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /generate (scope: generate:write)
+      def create(body = {}, query: nil, **fields)
+        @transport.request("POST", "/generate", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /generate/enhance (scope: generate:write)
+      def enhance(body = {}, query: nil, **fields)
+        @transport.request("POST", "/generate/enhance", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /generate/hashtags (scope: generate:write)
+      def hashtags(body = {}, query: nil, **fields)
+        @transport.request("POST", "/generate/hashtags", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /generate/image (scope: generate:write)
+      def image(body = {}, query: nil, **fields)
+        @transport.request("POST", "/generate/image", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /generate/optimize (scope: generate:write)
+      def optimize(query: nil)
+        @transport.request("GET", "/generate/optimize", query: query)
+      end
+
+      # POST /generate/plan (scope: generate:write)
+      def plan(body = {}, query: nil, **fields)
+        @transport.request("POST", "/generate/plan", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `growth` resource group.
+    class GrowthResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /growth/next-opportunity (scope: analytics:read)
+      def next_opportunity(query: nil)
+        @transport.request("GET", "/growth/next-opportunity", query: query)
+      end
+
+      # GET /growth/opportunities (scope: analytics:read)
+      def opportunities(query: nil)
+        @transport.request("GET", "/growth/opportunities", query: query)
+      end
+
+      # GET /growth/overview (scope: analytics:read)
+      def overview(query: nil)
+        @transport.request("GET", "/growth/overview", query: query)
+      end
+
+      # GET /growth/playbooks (scope: analytics:read)
+      def playbooks(query: nil)
+        @transport.request("GET", "/growth/playbooks", query: query)
+      end
+    end
+
+    # The `media` resource group.
+    class MediaResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # DELETE /media/:id (scope: media:write)
+      def delete(id, query: nil)
+        @transport.request("DELETE", "/media/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /media (scope: media:read)
+      def list(query: nil)
+        @transport.request("GET", "/media", query: query)
+      end
+    end
+
+    # The `notifications` resource group.
+    class NotificationsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /notifications (scope: notifications:read)
+      def list(query: nil)
+        @transport.request("GET", "/notifications", query: query)
+      end
+
+      # POST /notifications/read-all (scope: notifications:write)
+      def read_all(query: nil)
+        @transport.request("POST", "/notifications/read-all", query: query)
+      end
+
+      # PATCH /notifications/:id (scope: notifications:write)
+      def update(id, query: nil)
+        @transport.request("PATCH", "/notifications/#{Transport.enc(id)}", query: query)
+      end
+    end
+
+    # The `personaforge` resource group.
+    class PersonaforgeResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /personaforge/replies/approve (scope: personas:write)
+      def approve_replies(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/replies/approve", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /personaforge/bio (scope: generate:write)
+      def bio(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/bio", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /personaforge/competitors (scope: personas:write)
+      def create_competitors(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/competitors", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /personaforge/personas (scope: personas:write)
+      def create_persona(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/personas", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /personaforge/replies (scope: personas:write)
+      def create_replies(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/replies", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /personaforge/voice (scope: personas:write)
+      def create_voice(query: nil)
+        @transport.request("POST", "/personaforge/voice", query: query)
+      end
+
+      # DELETE /personaforge/personas/:id (scope: personas:write)
+      def delete_persona(id, query: nil)
+        @transport.request("DELETE", "/personaforge/personas/#{Transport.enc(id)}", query: query)
+      end
+
+      # POST /personaforge/generate (scope: generate:write)
+      def generate(body = {}, query: nil, **fields)
+        @transport.request("POST", "/personaforge/generate", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /personaforge/personas/:id (scope: personas:read)
+      def get_persona(id, query: nil)
+        @transport.request("GET", "/personaforge/personas/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /personaforge/voice (scope: personas:read)
+      def get_voice(query: nil)
+        @transport.request("GET", "/personaforge/voice", query: query)
+      end
+
+      # GET /personaforge/competitors (scope: personas:read)
+      def list_competitors(query: nil)
+        @transport.request("GET", "/personaforge/competitors", query: query)
+      end
+
+      # GET /personaforge/personas (scope: personas:read)
+      def list_personas(query: nil)
+        @transport.request("GET", "/personaforge/personas", query: query)
+      end
+
+      # GET /personaforge/replies (scope: personas:read)
+      def list_replies(query: nil)
+        @transport.request("GET", "/personaforge/replies", query: query)
+      end
+
+      # GET /personaforge/personas/status/:jobId (scope: personas:read)
+      def persona_status(job_id, query: nil)
+        @transport.request("GET", "/personaforge/personas/status/#{Transport.enc(job_id)}", query: query)
+      end
+
+      # PATCH /personaforge/personas/:id (scope: personas:write)
+      def update_persona(id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/personaforge/personas/#{Transport.enc(id)}", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `posts` resource group.
+    class PostsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /calendar (scope: posts:read)
+      def calendar(query: nil)
+        @transport.request("GET", "/calendar", query: query)
+      end
+
+      # DELETE /posts (scope: posts:write)
+      def cancel(body = {}, query: nil, **fields)
+        @transport.request("DELETE", "/posts", query: query, body: Transport.body(body, fields))
+      end
+
+      # DELETE /posts/:id (scope: posts:write)
+      def delete(id, query: nil)
+        @transport.request("DELETE", "/posts/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /posts (scope: posts:read)
+      def list(query: nil)
+        @transport.request("GET", "/posts", query: query)
+      end
+
+      # POST /posts/:id/reply (scope: posts:write)
+      def reply(id, body = {}, query: nil, **fields)
+        @transport.request("POST", "/posts/#{Transport.enc(id)}/reply", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /posts/:id/revert (scope: posts:write)
+      def revert(id, query: nil)
+        @transport.request("POST", "/posts/#{Transport.enc(id)}/revert", query: query)
+      end
+
+      # POST /posts/revert-batch (scope: posts:write)
+      def revert_batch(body = {}, query: nil, **fields)
+        @transport.request("POST", "/posts/revert-batch", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /schedule (scope: schedule:write)
+      def schedule(body = {}, query: nil, **fields)
+        @transport.request("POST", "/schedule", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /posts/:id/share (scope: posts:write)
+      def share(id, query: nil)
+        @transport.request("POST", "/posts/#{Transport.enc(id)}/share", query: query)
+      end
+
+      # DELETE /posts/:id/share (scope: posts:write)
+      def unshare(id, query: nil)
+        @transport.request("DELETE", "/posts/#{Transport.enc(id)}/share", query: query)
+      end
+
+      # PATCH /posts/:id (scope: posts:write)
+      def update(id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/posts/#{Transport.enc(id)}", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `post_tags` resource group.
+    class PostTagsResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /post-tags (scope: posts:write)
+      def create(body = {}, query: nil, **fields)
+        @transport.request("POST", "/post-tags", query: query, body: Transport.body(body, fields))
+      end
+
+      # DELETE /post-tags/:id (scope: posts:write)
+      def delete(id, query: nil)
+        @transport.request("DELETE", "/post-tags/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /post-tags (scope: posts:read)
+      def list(query: nil)
+        @transport.request("GET", "/post-tags", query: query)
+      end
+
+      # PATCH /post-tags/:id (scope: posts:write)
+      def update(id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/post-tags/#{Transport.enc(id)}", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `post_templates` resource group.
+    class PostTemplatesResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /post-templates (scope: posts:write)
+      def create(body = {}, query: nil, **fields)
+        @transport.request("POST", "/post-templates", query: query, body: Transport.body(body, fields))
+      end
+
+      # DELETE /post-templates/:id (scope: posts:write)
+      def delete(id, query: nil)
+        @transport.request("DELETE", "/post-templates/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /post-templates/:id (scope: posts:read)
+      def get(id, query: nil)
+        @transport.request("GET", "/post-templates/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /post-templates (scope: posts:read)
+      def list(query: nil)
+        @transport.request("GET", "/post-templates", query: query)
+      end
+
+      # PATCH /post-templates/:id (scope: posts:write)
+      def update(id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/post-templates/#{Transport.enc(id)}", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `trendpulse` resource group.
+    class TrendpulseResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /trendpulse/platform-content (scope: trends:write)
+      def create_platform_content(body = {}, query: nil, **fields)
+        @transport.request("POST", "/trendpulse/platform-content", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /trendpulse/digest (scope: trends:write)
+      def digest(query: nil)
+        @transport.request("POST", "/trendpulse/digest", query: query)
+      end
+
+      # POST /trendpulse/fetch (scope: trends:write)
+      def fetch(query: nil)
+        @transport.request("POST", "/trendpulse/fetch", query: query)
+      end
+
+      # GET /trendpulse/hooks (scope: trends:read)
+      def hooks(query: nil)
+        @transport.request("GET", "/trendpulse/hooks", query: query)
+      end
+
+      # GET /trendpulse (scope: trends:read)
+      def list(query: nil)
+        @transport.request("GET", "/trendpulse", query: query)
+      end
+
+      # GET /trendpulse/platform-content (scope: trends:read)
+      def list_platform_content(query: nil)
+        @transport.request("GET", "/trendpulse/platform-content", query: query)
+      end
+
+      # GET /trendpulse/performance (scope: analytics:read)
+      def performance(query: nil)
+        @transport.request("GET", "/trendpulse/performance", query: query)
+      end
+
+      # POST /trendpulse/pipeline (scope: schedule:write)
+      def pipeline(body = {}, query: nil, **fields)
+        @transport.request("POST", "/trendpulse/pipeline", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /trendpulse (scope: trends:write)
+      def refresh(body = {}, query: nil, **fields)
+        @transport.request("POST", "/trendpulse", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /trendpulse/platform-content/use (scope: trends:write)
+      def use_platform_content(body = {}, query: nil, **fields)
+        @transport.request("POST", "/trendpulse/platform-content/use", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `video` resource group.
+    class VideoResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # GET /video/avatars (scope: media:read)
+      def avatars(query: nil)
+        @transport.request("GET", "/video/avatars", query: query)
+      end
+
+      # POST /video/generate (scope: generate:write)
+      def generate(body = {}, query: nil, **fields)
+        @transport.request("POST", "/video/generate", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /video/script (scope: generate:write)
+      def script(body = {}, query: nil, **fields)
+        @transport.request("POST", "/video/script", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /video/status/:jobId (scope: media:read)
+      def status(job_id, query: nil)
+        @transport.request("GET", "/video/status/#{Transport.enc(job_id)}", query: query)
+      end
+
+      # GET /video/voices (scope: media:read)
+      def voices(query: nil)
+        @transport.request("GET", "/video/voices", query: query)
+      end
+    end
+
+    # The `webhooks` resource group.
+    class WebhooksResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /webhooks/outbound (scope: webhooks:write)
+      def create_outbound(body = {}, query: nil, **fields)
+        @transport.request("POST", "/webhooks/outbound", query: query, body: Transport.body(body, fields))
+      end
+
+      # DELETE /webhooks/outbound/:id (scope: webhooks:write)
+      def delete_outbound(id, query: nil)
+        @transport.request("DELETE", "/webhooks/outbound/#{Transport.enc(id)}", query: query)
+      end
+
+      # GET /webhooks/outbound (scope: webhooks:read)
+      def list_outbound(query: nil)
+        @transport.request("GET", "/webhooks/outbound", query: query)
+      end
+
+      # PATCH /webhooks/outbound/:id (scope: webhooks:write)
+      def update_outbound(id, body = {}, query: nil, **fields)
+        @transport.request("PATCH", "/webhooks/outbound/#{Transport.enc(id)}", query: query, body: Transport.body(body, fields))
+      end
+    end
+
+    # The `workspaces` resource group.
+    class WorkspacesResource
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # POST /workspaces/:id/members (scope: workspaces:write)
+      def add_member(id, body = {}, query: nil, **fields)
+        @transport.request("POST", "/workspaces/#{Transport.enc(id)}/members", query: query, body: Transport.body(body, fields))
+      end
+
+      # POST /workspaces (scope: workspaces:write)
+      def create(body = {}, query: nil, **fields)
+        @transport.request("POST", "/workspaces", query: query, body: Transport.body(body, fields))
+      end
+
+      # GET /workspaces (scope: workspaces:read)
+      def list(query: nil)
+        @transport.request("GET", "/workspaces", query: query)
+      end
+
+      # GET /workspaces/:id/members (scope: workspaces:read)
+      def members(id, query: nil)
+        @transport.request("GET", "/workspaces/#{Transport.enc(id)}/members", query: query)
+      end
+
+      # DELETE /workspaces/:id/members (scope: workspaces:write)
+      def remove_member(id, member_id, query: nil)
+        @transport.request("DELETE", "/workspaces/#{Transport.enc(id)}/members", query: (query || {}).merge("memberId" => member_id))
+      end
+    end
+
+    # Every resource group, generated from sdks/manifest.json.
+    class Resources
+      attr_reader :analytics, :composer, :connections, :contentripple, :drafts, :generate, :growth, :media, :notifications, :personaforge, :posts, :post_tags, :post_templates, :trendpulse, :video, :webhooks, :workspaces
+
+      def initialize(transport)
+        @analytics = AnalyticsResource.new(transport)
+        @composer = ComposerResource.new(transport)
+        @connections = ConnectionsResource.new(transport)
+        @contentripple = ContentrippleResource.new(transport)
+        @drafts = DraftsResource.new(transport)
+        @generate = GenerateResource.new(transport)
+        @growth = GrowthResource.new(transport)
+        @media = MediaResource.new(transport)
+        @notifications = NotificationsResource.new(transport)
+        @personaforge = PersonaforgeResource.new(transport)
+        @posts = PostsResource.new(transport)
+        @post_tags = PostTagsResource.new(transport)
+        @post_templates = PostTemplatesResource.new(transport)
+        @trendpulse = TrendpulseResource.new(transport)
+        @video = VideoResource.new(transport)
+        @webhooks = WebhooksResource.new(transport)
+        @workspaces = WorkspacesResource.new(transport)
+      end
+    end
+  end
+end

data/lib/misarpost.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# MisarPost Ruby SDK — https://docs.misar.io/post
+require_relative "misarpost/errors"
+require_relative "misarpost/core/transport"
+require_relative "misarpost/core/pagination"
+require_relative "misarpost/core/webhooks"
+require_relative "misarpost/generated/resources"
+require_relative "misarpost/client"

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: misarpost
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Misar.AI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Schedule and publish posts across every connected channel, generate and
+  repurpose content with AI, research trends, run PersonaForge and read analytics
+  — every MisarPost API endpoint, with retries and plan-limit upgrade offers. Standard
+  library only.
+email:
+- hello@misar.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/misarpost.rb
+- lib/misarpost/client.rb
+- lib/misarpost/core/pagination.rb
+- lib/misarpost/core/transport.rb
+- lib/misarpost/core/webhooks.rb
+- lib/misarpost/errors.rb
+- lib/misarpost/generated/resources.rb
+homepage: https://www.misarpost.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.misarpost.com
+  documentation_uri: https://docs.misar.io/post
+  source_code_uri: https://github.com/Misar-AI/misarpost-sdks/tree/main/ruby
+  changelog_uri: https://github.com/Misar-AI/misarpost-sdks/blob/main/ruby/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Misar-AI/misarpost-sdks/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+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: MisarPost social publishing API client for Ruby.
+test_files: []