@jini-ai/agent-plugins 0.6.17 → 0.6.19

package/resend/lib/errors.mjs

@@ -0,0 +1,25 @@
+// @ts-check
+
+/** A non-empty string field of a parsed body, else the fallback. @param {unknown} value @param {string} fallback */
+function nonEmpty(value, fallback) {
+  return typeof value === "string" && value !== "" ? value : fallback;
+}
+
+/**
+ * Resend's error body is `{statusCode, message, name}`; `name` becomes `errorCode`. A non-JSON body
+ * (a proxy error page) still yields a usable result. Never throws.
+ * @param {{ status: number, bodyText: string }} required
+ * @param {{ fallback?: { errorCode: string, message: string } }} [options]
+ * @returns {{ errorCode: string, message: string }}
+ */
+export function parseErrorBody({ status, bodyText }, options = {}) {
+  const fallback = options.fallback ?? { errorCode: `HTTP_${status}`, message: bodyText || `Resend responded with HTTP ${status}` };
+  try {
+    const parsed = JSON.parse(bodyText);
+    return { errorCode: nonEmpty(parsed?.name, fallback.errorCode), message: nonEmpty(parsed?.message, fallback.message) };
+  } catch {
+    // Non-JSON body: keep the raw text above.
+    return fallback;
+  }
+}
+

package/resend/lib/feedback.mjs

@@ -0,0 +1,118 @@
+// @ts-check
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+
+/**
+ * @file Resend delivery feedback: Svix webhook signature check and event normalization
+ * (Jini `MailFeedbackParser`). Neither function throws; a bad input is `false` or `{ error }`.
+ *
+ * Svix signs `${svix-id}.${svix-timestamp}.${raw body}` with HMAC-SHA256 under the base64 key after
+ * the `whsec_` prefix, and sends space-separated `v1,<base64>` signatures (several while Resend
+ * rotates its own key). Any of our `secrets` may match, so the operator can rotate theirs too.
+ * `sourceContext.module` is `unknown`: sends carry no Resend tags yet, so the originating module is
+ * not in the payload; suppression does not need it.
+ *
+ * @typedef {{ workspaceId: string, providerMessageId: string, sourceContext: { module: string },
+ *   kind: 'delivered' | 'bounced' | 'complained', eventId: string, recipient: string, hardBounce: boolean,
+ *   occurredAt: string }} FeedbackEvent
+ */
+
+/** Svix's replay window: a captured request older (or newer) than this is refused. */
+export const SVIX_TOLERANCE_SECONDS = 5 * 60;
+
+/** Resend event type to normalized kind; every other type (sent, opened, clicked, delayed) is ignored. */
+const KINDS = /** @type {const} */ ({ 'email.bounced': 'bounced', 'email.complained': 'complained', 'email.delivered': 'delivered' });
+
+/** @param {string} secret @returns {Buffer} */
+function secretKey(secret) {
+  return Buffer.from(secret.startsWith('whsec_') ? secret.slice('whsec_'.length) : secret, 'base64');
+}
+
+/** The `v1` signatures of a `svix-signature` header, decoded. @param {string} header @returns {Buffer[]} */
+function v1Signatures(header) {
+  return header.split(' ').map((entry) => entry.split(',')).filter(([version, value]) => version === 'v1' && value)
+    .map(([, value]) => Buffer.from(/** @type {string} */ (value), 'base64'));
+}
+
+/** Constant-time compare; differing lengths never match. @param {Buffer} a @param {Buffer} b */
+function sameBytes(a, b) {
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+
+/**
+ * @param {{ rawBody: Uint8Array, headers: Readonly<Record<string, string>>, secrets: readonly string[], now: number }} required
+ * @returns {boolean}
+ */
+export function verify({ rawBody, headers, secrets, now }) {
+  try {
+    const id = headers['svix-id'];
+    const timestamp = headers['svix-timestamp'];
+    const signature = headers['svix-signature'];
+    if (!id || !timestamp || !signature || !/^\d+$/.test(timestamp)) return false;
+    if (Math.abs(now / 1000 - Number(timestamp)) > SVIX_TOLERANCE_SECONDS) return false;
+    const signed = Buffer.concat([Buffer.from(`${id}.${timestamp}.`), Buffer.from(rawBody)]);
+    const offered = v1Signatures(signature);
+    return secrets.some((secret) => {
+      const expected = createHmac('sha256', secretKey(secret)).update(signed).digest();
+      return offered.some((candidate) => sameBytes(candidate, expected));
+    });
+  } catch {
+    return false;
+  }
+}
+
+/** @param {unknown} value @returns {value is Record<string, any>} */
+function isObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Resend's `bounce.type`: `Permanent` (or `hard`) is a hard bounce; `Transient`/`Undetermined` are not. @param {any} data */
+function isHardBounce(data) {
+  const type = isObject(data.bounce) ? String(data.bounce.type ?? '').toLowerCase() : '';
+  return type === 'permanent' || type === 'hard';
+}
+
+/** @param {unknown} to @returns {string[]} */
+function recipientsOf(to) {
+  const list = Array.isArray(to) ? to : [to];
+  return list.filter((entry) => typeof entry === 'string' && entry.trim() !== '').map((entry) => entry.trim().toLowerCase());
+}
+
+/** A non-empty string, else undefined. @param {unknown} value */
+const nonEmpty = (value) => (typeof value === 'string' && value !== '' ? value : undefined);
+
+/**
+ * The event id: Svix's `svix-id` (stable across its retries of one message), else the payload's own
+ * `id`, else a hash of the exact bytes (a retry resends identical bytes, so it hashes the same) for a
+ * host that passes no headers. Per recipient, so one event to many stays unique in the inbox.
+ * @param {any} payload @param {Uint8Array} rawBody @param {Readonly<Record<string, string>> | undefined} headers
+ */
+function baseIdOf(payload, rawBody, headers) {
+  return nonEmpty(headers?.['svix-id']) ?? nonEmpty(payload.id) ?? createHash('sha256').update(rawBody).digest('hex');
+}
+
+/**
+ * @param {{ rawBody: Uint8Array, workspaceId: string, headers?: Readonly<Record<string, string>> }} required
+ * @returns {readonly FeedbackEvent[] | { error: string }}
+ */
+export function parse({ rawBody, workspaceId, headers }) {
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(rawBody).toString('utf8'));
+  } catch {
+    return { error: 'body is not JSON' };
+  }
+  if (!isObject(payload) || typeof payload.type !== 'string' || !isObject(payload.data)) return { error: 'not a Resend webhook event' };
+  const kind = KINDS[/** @type {keyof typeof KINDS} */ (payload.type)];
+  if (!kind) return [];
+  const { data } = payload;
+  const recipients = recipientsOf(data.to);
+  const occurredAt = String(payload.created_at ?? data.created_at ?? new Date().toISOString());
+  const base = baseIdOf(payload, rawBody, headers);
+  return recipients.map((recipient) => ({
+    workspaceId, providerMessageId: typeof data.email_id === 'string' ? data.email_id : '', sourceContext: { module: 'unknown' },
+    kind, eventId: recipients.length > 1 ? `${base}:${recipient}` : base, recipient,
+    hardBounce: kind === 'bounced' && isHardBounce(data), occurredAt,
+  }));
+}
+
+export const feedback = { verify, parse };

package/resend/mcp.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "resend": {
+      "type": "streamable-http",
+      "url": "https://mcp.resend.com/mcp",
+      "tovuTokenAuth": {
+        "helpUrl": "https://resend.com/api-keys",
+        "probeUrl": "https://api.resend.com/domains"
+      }
+    }
+  }
+}

package/resend/plugin.json

@@ -0,0 +1,192 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "resend",
+  "version": "0.2.1",
+  "description": "Sends the site's email (sign-in links, form notifications, newsletters) through Resend's hosted email API, and connects the assistant to Resend's own hosted MCP server for work on the Resend account itself: domains and their DNS verification, broadcasts, contacts, segments, topics, templates, logs and usage. Ships the mail adapter (a host loads it only when the host shipped it) and the know-how to set both up: a sending key saved through credential_save for site mail, and a separate Full access key saved through the secure account card for the account tools.",
+  "author": "Tovu",
+  "license": "Apache-2.0",
+  "extensions": {
+    "tovu": {
+      "vendorAliases": ["resend.com", "HttpApiMailerAdapter"],
+      "summary": "Sends your site's emails through Resend, and lets the assistant manage your Resend account: domains, broadcasts and contacts.",
+      "id": "tovu/resend",
+      "provides": [
+        "outbound-mail"
+      ],
+      "mcpServers": {
+        "resend": {
+          "tovuAuthMode": "none",
+          "tovuDefaultTools": {
+            "allow": [
+              "list-domains",
+              "get-domain",
+              "get-domain-claim",
+              "list-emails",
+              "get-email",
+              "get-email-metrics",
+              "list-received-emails",
+              "get-received-email",
+              "list-received-email-attachments",
+              "get-received-email-attachment",
+              "list-broadcasts",
+              "get-broadcast",
+              "list-broadcast-recipients",
+              "list-broadcast-clicked-links",
+              "list-contacts",
+              "get-contact",
+              "list-contact-segments",
+              "list-contact-topics",
+              "list-segments",
+              "get-segment",
+              "list-topics",
+              "get-topic",
+              "list-contact-properties",
+              "get-contact-property",
+              "list-templates",
+              "get-template",
+              "list-webhooks",
+              "get-webhook",
+              "list-webhook-events",
+              "get-webhook-event",
+              "list-webhook-event-attempts",
+              "list-api-keys",
+              "list-logs",
+              "get-log",
+              "get-usage",
+              "list-suppressions",
+              "get-suppression",
+              "create-domain",
+              "update-domain",
+              "verify-domain",
+              "create-domain-claim",
+              "verify-domain-claim",
+              "send-email",
+              "send-batch-emails",
+              "cancel-email",
+              "update-email",
+              "create-broadcast",
+              "update-broadcast",
+              "compose-broadcast",
+              "cancel-broadcast",
+              "create-contact",
+              "update-contact",
+              "add-contact-to-segment",
+              "update-contact-topics",
+              "create-segment",
+              "update-segment",
+              "create-topic",
+              "update-topic",
+              "create-template",
+              "update-template",
+              "compose-template",
+              "publish-template"
+            ],
+            "write": [
+              "create-domain",
+              "update-domain",
+              "verify-domain",
+              "create-domain-claim",
+              "verify-domain-claim",
+              "send-email",
+              "send-batch-emails",
+              "cancel-email",
+              "update-email",
+              "create-broadcast",
+              "update-broadcast",
+              "compose-broadcast",
+              "cancel-broadcast",
+              "create-contact",
+              "update-contact",
+              "add-contact-to-segment",
+              "update-contact-topics",
+              "create-segment",
+              "update-segment",
+              "create-topic",
+              "update-topic",
+              "create-template",
+              "update-template",
+              "compose-template",
+              "publish-template"
+            ],
+            "read": [
+              "list-domains",
+              "get-domain",
+              "get-domain-claim",
+              "list-emails",
+              "get-email",
+              "get-email-metrics",
+              "list-received-emails",
+              "get-received-email",
+              "list-received-email-attachments",
+              "get-received-email-attachment",
+              "list-broadcasts",
+              "get-broadcast",
+              "list-broadcast-recipients",
+              "list-broadcast-clicked-links",
+              "list-contacts",
+              "get-contact",
+              "list-contact-segments",
+              "list-contact-topics",
+              "list-segments",
+              "get-segment",
+              "list-topics",
+              "get-topic",
+              "list-contact-properties",
+              "get-contact-property",
+              "list-templates",
+              "get-template",
+              "list-webhooks",
+              "get-webhook",
+              "list-webhook-events",
+              "get-webhook-event",
+              "list-webhook-event-attempts",
+              "list-api-keys",
+              "list-logs",
+              "get-log",
+              "get-usage",
+              "list-suppressions",
+              "get-suppression"
+            ]
+          }
+        }
+      },
+      "credentialCards": [
+        {
+          "target": "resend-mcp",
+          "title": "Connect Resend with a Full access key",
+          "label": "Resend account",
+          "category": "ops",
+          "intro": "Let the assistant add and verify your email domain in Resend. This saves a separate account key and keeps your site's sending key.",
+          "usedFor": [
+            "Adds and verifies your email domain",
+            "Manages contacts and broadcasts",
+            "Manages email templates and reads email activity and account usage",
+            "Sends one-off emails you request"
+          ],
+          "keyHint": "In Resend, open API Keys → Create API Key. Choose Full access and all domains. Sending access cannot add or verify domains.",
+          "saveKind": "agent-plugin-token",
+          "saveTarget": "resend",
+          "helpUrl": "https://resend.com/api-keys",
+          "helpLabel": "Create a Full access key in Resend",
+          "baseUrl": "https://api.resend.com"
+        }
+      ]
+    }
+  },
+  "keywords": [
+    "resend",
+    "email",
+    "mail",
+    "send-email",
+    "transactional-email",
+    "newsletter",
+    "smtp-alternative",
+    "outbound-mail",
+    "domains",
+    "dns",
+    "broadcast",
+    "contacts",
+    "audience",
+    "mcp"
+  ]
+}

package/resend/skills/resend/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: resend
+description: Send the site's email through Resend, and manage the Resend account itself (domains and DNS verification, broadcasts, contacts, segments, topics, templates, logs, usage) through Resend's hosted MCP server. Covers which tools to use for what, the two keys and how each is saved through the host's secure form, verifying the sending domain, and what each send failure means in plain words.
+---
+
+# Resend: the site's email, and the Resend account
+
+## Scope
+
+Choose the card yourself from its `usedFor` list. Reuse a saved key for that
+task. Never offer a replacement unless the person asks.
+
+This plugin does two separate jobs. Keep them apart.
+
+1. **The sending card** (`resend`). The adapter ships in
+   this opt-in plugin. Enable it first in the host's email provider settings, then save its key.
+   Switching delivery is a separate step; enabling or saving alone never switches mail.
+2. **The account card** (`resend-mcp`).
+   This goes through Resend's own hosted MCP server, `https://mcp.resend.com/mcp`. Its tools appear
+   as `mcp__resend__<name>`, for example `mcp__resend__list-domains`.
+
+## Which tools to use
+
+**The host's own mail tools are the source of truth for the site's email.** Use them for anything about
+how this site sends:
+
+- `system_get_mail_status`: is mail set up, which provider, is the domain ready.
+- `mail_set_provider`: switch the site between Resend, SMTP and none.
+- `mail_send_test`: prove the site's mail works end to end.
+- `dns_*`: add or check the DNS records on the site's own domain.
+
+Never use `mcp__resend__send-email` to test or stand in for the site's mail: it skips the host's outbox,
+retries, suppression list and logs, so a pass there proves nothing about the site.
+
+**Use the `mcp__resend__*` tools for work on the Resend account itself**, when the person asks for it:
+
+- **Domains**: `list-domains`, `get-domain`, `create-domain`, `update-domain`, `verify-domain`, and
+  the domain-claim tools. `create-domain` returns the DNS records; add them with the host's `dns_*`
+  tools when the site's DNS is managed by the host, otherwise show them to the person. Then call
+  `verify-domain`.
+- **Broadcasts**: draft, update, compose and cancel. Sending a broadcast is not switched on by
+  default (see below); the site's own newsletter goes through the host.
+- **Contacts, segments, topics, contact properties, templates**: list, read, create, update.
+- **Emails**: one-off emails the person asks for (`send-email`, `send-batch-emails`, which ask the
+  person to confirm first), reading sent and received emails, cancelling a scheduled one.
+- **Logs, usage, suppressions, webhooks, API keys**: read only.
+
+**Off by default:** every `remove-*` tool, `send-broadcast`, creating or changing API keys,
+creating, changing or rotating webhooks, and revoking sign-ins. Removals cannot be undone, a
+broadcast mails a whole audience, and new keys or webhook secrets would land in the chat. If the
+person really needs one of these, do it in the Resend dashboard, or tell them they can switch that
+tool on under Settings for this connection.
+
+## Connect the Resend account (before any `mcp__resend__*` tool)
+
+The account connection uses a separate **Full access** API key, not browser OAuth. Reuse a saved
+account key; never offer to replace it unless the person asks. Call
+`agent_plugin_connect { pluginId: "resend" }` to check the saved connection or open its secure key card.
+Only say the card is open after the tool emits it. A cancelled or expired card is not a connection.
+
+If opening the account card directly, use
+`credential_save { kind: "plugin-provider", target: "resend-mcp" }`. Explain first:
+"This is a separate Full access key so I can add and verify your domain. It keeps your site's
+existing sending key." Then tell the person:
+1. Sign in at [resend.com/api-keys](https://resend.com/api-keys) and choose **Create API Key**.
+2. Permission: **Full access** (a "Sending access" key is refused). Domain: all domains.
+3. Paste it into the secure form the host shows. Never into the chat.
+
+- `{ status: "connected" }`: go ahead.
+- `{ status: "not-connected" }`: explain the returned outcome; do not call the account tools yet.
+- The form says the key was rejected: it is a "Sending access" key. Make a Full access one.
+- The form says Resend is unavailable right after a save: most often the key was mistyped (Resend
+  answers a malformed key that way). Ask the person to copy it again; retry once, then wait.
+
+Never ask for the key in chat, and never put it in any tool argument.
+
+## Set up the site's email
+
+1. **Get a sending key.** The person signs in at [resend.com/api-keys](https://resend.com/api-keys)
+   and creates a key with **Sending access** (only sending; the site needs nothing more). This is a
+   different key from the Full access one above.
+2. **Save it through the Connect Resend card:** `credential_save { kind: "plugin-provider", target: "resend" }`.
+   The card asks only for the key and saves it under the label the host reads ("Tovu Mail — Resend API").
+   Never ask for the key in chat. If a sending key is already saved, reuse it. Only open a replacement
+   card if the person explicitly asks to replace that key; explain that it REPLACES the saved key.
+3. **Verify the sending domain.** Until it is verified, Resend only sends to the account's own
+   address. Check with `system_get_mail_status`; add records with `dns_*` (or, when the account is
+   connected, `mcp__resend__create-domain` then `mcp__resend__verify-domain`).
+4. **Select Resend** with `mail_set_provider { providerId: "resend" }`. The change and saved key
+   take effect on the next email. Never ask the person to restart the host.
+5. Prove it with `mail_send_test`.
+
+## What a failure means
+
+- `validation_error`: a bad address or an unverified sending domain. Fix the address or verify the domain.
+- `missing_api_key`, `invalid_api_key`, `restricted_api_key`: the saved key is wrong or lacks sending
+  access. Explain the failure and needed access. Only after an
+  explicit replacement request, use `credential_save { kind: "api", target: "Tovu Mail — Resend API" }`.
+- `rate_limit_exceeded`, HTTP 5xx, `TRANSPORT_ERROR`: temporary. The host retries these.
+
+## Bounces and complaints (webhook)
+
+Resend can report hard bounces and spam complaints to the site through a signed webhook, so the
+site stops mailing those addresses. The endpoint address, the events to send, how the signing
+secret is saved and how it is rotated are the host's: follow the host guidance for this plugin.
+Set the webhook up in the Resend dashboard, not with the MCP tools: the signing secret must not
+pass through the chat, and never ask for it in chat.

package/resend/tovu-mail-adapters.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 2,
+  "adapters": [
+    {
+      "id": "resend",
+      "label": "Resend",
+      "module": "adapters/resend.mjs",
+      "credentialLabel": "Tovu Mail — Resend API",
+      "credentialKeys": ["token"],
+      "feedback": true,
+      "credentialCard": {
+        "title": "Connect Resend",
+        "usedFor": ["Sends your site's emails (sign-in links, form notices, newsletters)"],
+        "intro": "Connect Resend so this site can send its email (sign-in links, confirmations, form notifications).",
+        "helpUrl": "https://resend.com/api-keys",
+        "helpLabel": "Get a key at resend.com/api-keys",
+        "keyHint": "Create a key with Sending access",
+        "baseUrl": "https://api.resend.com"
+      }
+    }
+  ]
+}

package/s3-compatible/NOTES.md

@@ -0,0 +1,11 @@
+# S3-compatible — implementation notes
+
+Host-specific notes moved out of the first host's core comments (2026-10-22, vendor-to-plugins). Core describes these
+behaviours generically; the vendor detail lives here.
+
+- **Publish history.** An S3-compatible publish has no `deploymentId`; the "uploaded, not yet confirmed
+  reachable" outcome records `false` reachability.
+- **Account label.** No account field exists to read; the account-label heal skips these credentials.
+- **Security headers.** Buckets have no header config file here, so an export carries only what HTML can
+  say (core `withSecurityMeta`). With a CDN such as CloudFront, `404.html` at the output root is the
+  convention it looks for.

package/s3-compatible/mcp.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {}
+}