@nimbus-dev/connectors 0.2.1 → 0.2.3

package/connectors/dbt/src/tools.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { createJsonGetter, envAuthHeaders, optionalBaseUrl } from "../../../shared/env-json-api.ts";
+import { mcpJsonResult as jsonResult } from "../../../shared/mcp-tool-kit.ts";
+import type { ZodToolRegistrar } from "../../../shared/run-read-only-mcp-connector.ts";
+import { filterDbtJobs } from "./search-filter.ts";
+
+const DEFAULT_API_BASE = "https://cloud.getdbt.com";
+
+const dbtGet = createJsonGetter({
+  base: () => `${optionalBaseUrl("DBT_API_BASE", DEFAULT_API_BASE)}/api/v2`,
+  label: "dbt Cloud",
+  headers: envAuthHeaders({ env: "DBT_TOKEN", scheme: "Token" }),
+});
+
+function dataFrom(root: unknown): unknown[] {
+  if (Array.isArray(root)) {
+    return root;
+  }
+  const data = (root as { data?: unknown } | null)?.data;
+  return Array.isArray(data) ? data : [];
+}
+
+/** Tool names exposed by this connector — for contract/introspection tests. */
+export const DBT_TOOL_NAMES = ["dbt_get", "dbt_list", "dbt_search"] as const;
+
+export function registerDbtTools(reg: ZodToolRegistrar): void {
+  reg(
+    "dbt_list",
+    "List dbt Cloud accounts, or jobs for an account. Without `accountId`, returns the account's accounts (`/accounts/`). With `accountId`, returns that account's jobs (`/accounts/{accountId}/jobs/`), capped at `limit` (default 100). Returns the raw dbt Cloud envelope (`{ data: [...] }`).",
+    z.object({
+      accountId: z.number().int().optional(),
+      limit: z.number().int().min(1).max(500).optional(),
+    }),
+    async (p) => {
+      if (p.accountId === undefined) {
+        return jsonResult(await dbtGet("/accounts/"));
+      }
+      const search = new URLSearchParams({ limit: String(p.limit ?? 100) });
+      return jsonResult(
+        await dbtGet(
+          `/accounts/${encodeURIComponent(String(p.accountId))}/jobs/?${search.toString()}`,
+        ),
+      );
+    },
+  );
+
+  reg(
+    "dbt_get",
+    "Fetch one dbt Cloud job by `accountId` + `jobId` (`/accounts/{accountId}/jobs/{jobId}/`). Returns the raw dbt Cloud envelope. Throws when no such job exists.",
+    z.object({
+      accountId: z.number().int(),
+      jobId: z.number().int(),
+    }),
+    async (p) => {
+      return jsonResult(
+        await dbtGet(
+          `/accounts/${encodeURIComponent(String(p.accountId))}/jobs/${encodeURIComponent(String(p.jobId))}/`,
+        ),
+      );
+    },
+  );
+
+  reg(
+    "dbt_search",
+    "Substring search across an account's dbt Cloud jobs. Matches the query against job name, dbt version, and id (case-insensitive). Returns a `{ matches: [...] }` envelope.",
+    z.object({
+      accountId: z.number().int(),
+      query: z.string().min(1),
+      limit: z.number().int().min(1).max(200).optional(),
+    }),
+    async (p) => {
+      const search = new URLSearchParams({ limit: "500" });
+      const root = await dbtGet(
+        `/accounts/${encodeURIComponent(String(p.accountId))}/jobs/?${search.toString()}`,
+      );
+      const matches = filterDbtJobs(dataFrom(root), { query: p.query, limit: p.limit });
+      return jsonResult({ matches });
+    },
+  );
+}

package/connectors/dependencytrack/src/server.ts

@@ -1,80 +1,6 @@
-import { z } from "zod";
-import { searchToolInputSchema } from "../../../shared/mcp-search-tool.ts";
-import { mcpJsonResult as jsonResult } from "../../../shared/mcp-tool-kit.ts";
 import { runReadOnlyMcpConnector } from "../../../shared/run-read-only-mcp-connector.ts";
-import { filterDependencyTrackProjects } from "./search-filter.ts";
-
-function trimTrailingSlash(s: string): string {
-  return s.endsWith("/") ? s.slice(0, -1) : s;
-}
-
-function apiBase(): string {
-  const v = process.env["DEPENDENCYTRACK_URL"]?.trim();
-  if (v === undefined || v === "") {
-    throw new Error("DEPENDENCYTRACK_URL is not set");
-  }
-  return trimTrailingSlash(v);
-}
-
-function authHeader(): Record<string, string> {
-  const k = process.env["DEPENDENCYTRACK_API_KEY"]?.trim();
-  if (k === undefined || k === "") {
-    throw new Error("DEPENDENCYTRACK_API_KEY is not set");
-  }
-  return { "X-Api-Key": k, Accept: "application/json" };
-}
-
-async function dtGet(path: string): Promise<unknown> {
-  const res = await fetch(`${apiBase()}${path}`, { headers: authHeader() });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`Dependency-Track ${String(res.status)}: ${text.slice(0, 400)}`);
-  }
-  return JSON.parse(text) as unknown;
-}
-
-function projectsFrom(root: unknown): unknown[] {
-  return Array.isArray(root) ? root : [];
-}
+import { registerDependencytrackTools } from "./tools.ts";
 
 await runReadOnlyMcpConnector("nimbus-dependencytrack", (reg) => {
-  reg(
-    "dependencytrack_list",
-    "List Dependency-Track projects (GET /api/v1/project?pageSize=100&pageNumber=1&excludeInactive=false). Dependency-Track returns a JSON array of project objects, each embedding its current vulnerability metrics. The optional pageNumber arg (default 1) selects the page; pageSize is fixed at 100.",
-    z.object({
-      pageNumber: z.number().int().min(1).optional(),
-    }),
-    async (p) => {
-      const page = p.pageNumber ?? 1;
-      const root = await dtGet(
-        `/api/v1/project?pageSize=100&pageNumber=${encodeURIComponent(String(page))}&excludeInactive=false`,
-      );
-      return jsonResult({ items: projectsFrom(root) });
-    },
-  );
-
-  reg(
-    "dependencytrack_get",
-    "Fetch one Dependency-Track project by its UUID (GET /api/v1/project/{uuid}). Returns the project object directly (NOT wrapped in an array). Throws when no project with that UUID exists.",
-    z.object({
-      uuid: z.string().min(1),
-    }),
-    async (p) => {
-      return jsonResult(await dtGet(`/api/v1/project/${encodeURIComponent(p.uuid)}`));
-    },
-  );
-
-  reg(
-    "dependencytrack_search",
-    "Substring search across the first page of Dependency-Track projects. Matches the query (case-insensitive) against the project name, version, classifier, and tag names. Returns a matches envelope.",
-    searchToolInputSchema(100),
-    async (p) => {
-      const root = await dtGet("/api/v1/project?pageSize=100&pageNumber=1&excludeInactive=false");
-      const matches = filterDependencyTrackProjects(projectsFrom(root), {
-        query: p.query,
-        limit: p.limit,
-      });
-      return jsonResult({ matches });
-    },
-  );
+  registerDependencytrackTools(reg);
 });

package/connectors/dependencytrack/src/tools.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { createJsonGetter, envAuthHeaders, requiredBaseUrl } from "../../../shared/env-json-api.ts";
+import { searchToolInputSchema } from "../../../shared/mcp-search-tool.ts";
+import { mcpJsonResult as jsonResult } from "../../../shared/mcp-tool-kit.ts";
+import type { ZodToolRegistrar } from "../../../shared/run-read-only-mcp-connector.ts";
+import { filterDependencyTrackProjects } from "./search-filter.ts";
+
+const dtGet = createJsonGetter({
+  base: () => requiredBaseUrl("DEPENDENCYTRACK_URL"),
+  label: "Dependency-Track",
+  headers: envAuthHeaders({ env: "DEPENDENCYTRACK_API_KEY", scheme: "", header: "X-Api-Key" }),
+});
+
+function projectsFrom(root: unknown): unknown[] {
+  return Array.isArray(root) ? root : [];
+}
+
+/** Tool names exposed by this connector — for contract/introspection tests. */
+export const DEPENDENCYTRACK_TOOL_NAMES = [
+  "dependencytrack_list",
+  "dependencytrack_get",
+  "dependencytrack_search",
+] as const;
+
+export function registerDependencytrackTools(reg: ZodToolRegistrar): void {
+  reg(
+    "dependencytrack_list",
+    "List Dependency-Track projects (GET /api/v1/project?pageSize=100&pageNumber=1&excludeInactive=false). Dependency-Track returns a JSON array of project objects, each embedding its current vulnerability metrics. The optional pageNumber arg (default 1) selects the page; pageSize is fixed at 100.",
+    z.object({
+      pageNumber: z.number().int().min(1).optional(),
+    }),
+    async (p) => {
+      const page = p.pageNumber ?? 1;
+      const root = await dtGet(
+        `/api/v1/project?pageSize=100&pageNumber=${encodeURIComponent(String(page))}&excludeInactive=false`,
+      );
+      return jsonResult({ items: projectsFrom(root) });
+    },
+  );
+
+  reg(
+    "dependencytrack_get",
+    "Fetch one Dependency-Track project by its UUID (GET /api/v1/project/{uuid}). Returns the project object directly (NOT wrapped in an array). Throws when no project with that UUID exists.",
+    z.object({
+      uuid: z.string().min(1),
+    }),
+    async (p) => {
+      return jsonResult(await dtGet(`/api/v1/project/${encodeURIComponent(p.uuid)}`));
+    },
+  );
+
+  reg(
+    "dependencytrack_search",
+    "Substring search across the first page of Dependency-Track projects. Matches the query (case-insensitive) against the project name, version, classifier, and tag names. Returns a matches envelope.",
+    searchToolInputSchema(100),
+    async (p) => {
+      const root = await dtGet("/api/v1/project?pageSize=100&pageNumber=1&excludeInactive=false");
+      const matches = filterDependencyTrackProjects(projectsFrom(root), {
+        query: p.query,
+        limit: p.limit,
+      });
+      return jsonResult({ matches });
+    },
+  );
+}

package/connectors/discord/src/server.ts

@@ -1,93 +1,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-import { createRegisterSimpleTool, createZodToolRegistrar } from "../../../shared/mcp-tool-kit.ts";
-import { makeRestToolRegistrar } from "../../../shared/rest-tool-kit.ts";
-
-const DISCORD_API = "https://discord.com/api/v10";
-
-async function discordFetch(
-  token: string,
-  path: string,
-  init?: RequestInit,
-): Promise<{
-  ok: boolean;
-  status: number;
-  json: unknown;
-  text: string;
-}> {
-  const url = path.startsWith("http") ? path : `${DISCORD_API}${path}`;
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Authorization: `Bot ${token}`,
-      "User-Agent": "NimbusMCP (https://github.com/nimbus-dev/nimbus)",
-      ...(init?.headers as Record<string, string> | undefined),
-    },
-  });
-  const text = await res.text();
-  let json: unknown;
-  try {
-    json = JSON.parse(text) as unknown;
-  } catch {
-    json = null;
-  }
-  return { ok: res.ok, status: res.status, json, text };
-}
+import { registerDiscordTools } from "./tools.ts";
 
 const server = new McpServer({ name: "nimbus-discord", version: "0.1.0" });
 
-const registerSimpleTool = createRegisterSimpleTool(server);
-const reg = createZodToolRegistrar(registerSimpleTool);
-
-/** Standard Discord read tool: token → discordFetch(buildPath) → mcpJsonResultIfOk("Discord"). */
-const registerDiscordTool = makeRestToolRegistrar({
-  registrar: reg,
-  tokenEnv: "DISCORD_BOT_TOKEN",
-  serviceLabel: "Discord",
-  fetch: discordFetch,
-});
-
-registerDiscordTool(
-  "discord_guild_list",
-  "List guilds the bot is a member of.",
-  z.object({}),
-  () => "/users/@me/guilds",
-);
-
-registerDiscordTool(
-  "discord_channel_list",
-  "List channels in a guild (id, type, name).",
-  z.object({ guildId: z.string().min(1) }),
-  (parsed) => `/guilds/${encodeURIComponent(parsed.guildId)}/channels`,
-);
-
-registerDiscordTool(
-  "discord_channel_messages",
-  "List recent messages in a channel (newest first). Optional `after` snowflake for incremental fetch.",
-  z.object({
-    channelId: z.string().min(1),
-    limit: z.number().int().min(1).max(100).optional(),
-    after: z.string().optional(),
-  }),
-  (parsed) => {
-    const lim = parsed.limit ?? 50;
-    const u = new URL(`${DISCORD_API}/channels/${encodeURIComponent(parsed.channelId)}/messages`);
-    u.searchParams.set("limit", String(lim));
-    if (parsed.after !== undefined && parsed.after !== "") {
-      u.searchParams.set("after", parsed.after);
-    }
-    return `${u.pathname}${u.search}`;
-  },
-);
-
-registerDiscordTool(
-  "discord_thread_list",
-  "List active threads in a guild (includes public threads the bot can see).",
-  z.object({ guildId: z.string().min(1) }),
-  (parsed) => `/guilds/${encodeURIComponent(parsed.guildId)}/threads/active`,
-);
+registerDiscordTools(server);
 
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/connectors/discord/src/tools.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { createRegisterSimpleTool, createZodToolRegistrar } from "../../../shared/mcp-tool-kit.ts";
+import {
+  makeRestToolRegistrar,
+  type RestFetchResult,
+  toRestFetchResult,
+} from "../../../shared/rest-tool-kit.ts";
+
+const DISCORD_API = "https://discord.com/api/v10";
+
+async function discordFetch(
+  token: string,
+  path: string,
+  init?: RequestInit,
+): Promise<RestFetchResult> {
+  const url = path.startsWith("http") ? path : `${DISCORD_API}${path}`;
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      Authorization: `Bot ${token}`,
+      "User-Agent": "NimbusMCP (https://github.com/nimbus-dev/nimbus)",
+      ...(init?.headers as Record<string, string> | undefined),
+    },
+  });
+  return toRestFetchResult(res);
+}
+
+export function registerDiscordTools(server: { tool: (...args: never) => unknown }): void {
+  const registerSimpleTool = createRegisterSimpleTool(server);
+  const reg = createZodToolRegistrar(registerSimpleTool);
+
+  /** Standard Discord read tool: token → discordFetch(buildPath) → mcpJsonResultIfOk("Discord"). */
+  const registerDiscordTool = makeRestToolRegistrar({
+    registrar: reg,
+    tokenEnv: "DISCORD_BOT_TOKEN",
+    serviceLabel: "Discord",
+    fetch: discordFetch,
+  });
+
+  registerDiscordTool(
+    "discord_guild_list",
+    "List guilds the bot is a member of.",
+    z.object({}),
+    () => "/users/@me/guilds",
+  );
+
+  registerDiscordTool(
+    "discord_channel_list",
+    "List channels in a guild (id, type, name).",
+    z.object({ guildId: z.string().min(1) }),
+    (parsed) => `/guilds/${encodeURIComponent(parsed.guildId)}/channels`,
+  );
+
+  registerDiscordTool(
+    "discord_channel_messages",
+    "List recent messages in a channel (newest first). Optional `after` snowflake for incremental fetch.",
+    z.object({
+      channelId: z.string().min(1),
+      limit: z.number().int().min(1).max(100).optional(),
+      after: z.string().optional(),
+    }),
+    (parsed) => {
+      const lim = parsed.limit ?? 50;
+      const path = `/channels/${encodeURIComponent(parsed.channelId)}/messages`;
+      const u = new URL(`${DISCORD_API}${path}`);
+      u.searchParams.set("limit", String(lim));
+      if (parsed.after !== undefined && parsed.after !== "") {
+        u.searchParams.set("after", parsed.after);
+      }
+      // Relative to DISCORD_API, like every other tool here: the fetcher prefixes the base, which
+      // already ends in /api/v10, so returning `u.pathname` requested /api/v10/api/v10/….
+      return `${path}${u.search}`;
+    },
+  );
+
+  registerDiscordTool(
+    "discord_thread_list",
+    "List active threads in a guild (includes public threads the bot can see).",
+    z.object({ guildId: z.string().min(1) }),
+    (parsed) => `/guilds/${encodeURIComponent(parsed.guildId)}/threads/active`,
+  );
+}

package/connectors/elasticsearch/src/tools.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { isRecord, strField } from "../../../shared/cli-json-kit.ts";
+import { createJsonGetter, envAuthHeaders, requiredBaseUrl } from "../../../shared/env-json-api.ts";
 import { mcpJsonResult as jsonResult } from "../../../shared/mcp-tool-kit.ts";
 import type { ZodToolRegistrar } from "../../../shared/run-read-only-mcp-connector.ts";
 
@@ -18,43 +20,11 @@ export const ELASTICSEARCH_TOOL_NAMES = [
   "elasticsearch_search",
 ] as const;
 
-function trimTrailingSlash(s: string): string {
-  return s.endsWith("/") ? s.slice(0, -1) : s;
-}
-
-function baseUrl(): string {
-  const v = process.env["ELASTICSEARCH_URL"]?.trim();
-  if (v === undefined || v === "") {
-    throw new Error("ELASTICSEARCH_URL is not set");
-  }
-  return trimTrailingSlash(v);
-}
-
-function authHeaders(): Record<string, string> {
-  const k = process.env["ELASTICSEARCH_API_KEY"]?.trim();
-  if (k === undefined || k === "") {
-    throw new Error("ELASTICSEARCH_API_KEY is not set");
-  }
-  return { Authorization: `ApiKey ${k}`, Accept: "application/json" };
-}
-
-async function esGet(path: string): Promise<unknown> {
-  const res = await fetch(`${baseUrl()}${path}`, { headers: authHeaders() });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`Elasticsearch ${String(res.status)}: ${text.slice(0, 400)}`);
-  }
-  return JSON.parse(text) as unknown;
-}
-
-function isRecord(v: unknown): v is Record<string, unknown> {
-  return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-
-function strField(r: Record<string, unknown>, key: string): string {
-  const v = r[key];
-  return typeof v === "string" ? v : "";
-}
+const esGet = createJsonGetter({
+  base: () => requiredBaseUrl("ELASTICSEARCH_URL"),
+  label: "Elasticsearch",
+  headers: envAuthHeaders({ env: "ELASTICSEARCH_API_KEY", scheme: "ApiKey" }),
+});
 
 function indexEntries(parsed: unknown): unknown[] {
   return Array.isArray(parsed) ? parsed : [];

package/connectors/fastmail/src/jmap-client.ts

@@ -0,0 +1,202 @@
+/**
+ * The real Fastmail JMAP client over `fetch`.
+ *
+ * Moved out of `server.ts` for the same reason as every other connector's
+ * transport: an entry point that constructs its client at module scope cannot
+ * be imported by a test, so none of the session discovery, capability checks or
+ * request building below was reachable from one.
+ */
+
+import { optionalEnv } from "../../../shared/env-json-api.ts";
+import { requireProcessEnv } from "../../../shared/mcp-tool-kit.ts";
+import {
+  asRecord,
+  asString,
+  buildGetRequest,
+  buildListRequest,
+  buildSearchRequest,
+  CORE_CAPABILITY,
+  extractEmailList,
+  type JmapClient,
+  type JmapEmailView,
+  type JmapSession,
+  MAIL_CAPABILITY,
+  methodResponseArgs,
+  parseSession,
+  type SendMailInput,
+  type SendMailResult,
+  SUBMISSION_CAPABILITY,
+  validateApiUrl,
+  viewEmail,
+} from "./jmap-core.ts";
+
+const DEFAULT_BASE_URL = "https://api.fastmail.com";
+
+/** Parse a comma-separated address list (`Name <a@x>, b@y`) → JMAP address objects. */
+function parseAddressList(raw: string): Array<{ email: string }> {
+  return raw
+    .split(",")
+    .map((part) => {
+      // Extract the address inside `<...>` without a backtracking regex.
+      const open = part.indexOf("<");
+      const close = open === -1 ? -1 : part.indexOf(">", open + 1);
+      const inner = open !== -1 && close !== -1 ? part.slice(open + 1, close) : part;
+      return inner.trim();
+    })
+    .filter((email) => email !== "")
+    .map((email) => ({ email }));
+}
+
+/** Real Fastmail JMAP client over fetch. Discovers the session once, then reuses it. */
+class FetchJmapClient implements JmapClient {
+  private readonly baseUrl: string;
+  private readonly token: string;
+  private session: JmapSession | null = null;
+
+  constructor() {
+    this.token = requireProcessEnv("FASTMAIL_API_TOKEN");
+    // Only ONE trailing slash is dropped here — not `optionalBaseUrl`'s strip-them-all.
+    this.baseUrl = optionalEnv("FASTMAIL_BASE_URL", DEFAULT_BASE_URL).replace(/\/$/, "");
+  }
+
+  private headers(): Record<string, string> {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+  }
+
+  private async ensureSession(): Promise<JmapSession> {
+    if (this.session !== null) {
+      return this.session;
+    }
+    const res = await fetch(`${this.baseUrl}/jmap/session`, { headers: this.headers() });
+    if (!res.ok) {
+      throw new Error(`JMAP session failed: HTTP ${String(res.status)}`);
+    }
+    const session = parseSession(await res.json());
+    if (session === null) {
+      throw new Error("JMAP session response missing apiUrl / mail account");
+    }
+    // The apiUrl is server-controlled; pin it to the configured host before any
+    // authenticated POST is sent there (SSRF guard).
+    const validated: JmapSession = {
+      ...session,
+      apiUrl: validateApiUrl(session.apiUrl, this.baseUrl),
+    };
+    this.session = validated;
+    return validated;
+  }
+
+  private async api(body: unknown): Promise<unknown> {
+    const session = await this.ensureSession();
+    const res = await fetch(session.apiUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      throw new Error(`JMAP api failed: HTTP ${String(res.status)}`);
+    }
+    return res.json();
+  }
+
+  private async views(request: unknown): Promise<JmapEmailView[]> {
+    const out: JmapEmailView[] = [];
+    for (const raw of extractEmailList(await this.api(request))) {
+      const v = viewEmail(raw);
+      if (v !== null) {
+        out.push(v);
+      }
+    }
+    return out;
+  }
+
+  async list(limit: number): Promise<JmapEmailView[]> {
+    const session = await this.ensureSession();
+    return this.views(buildListRequest(session.accountId, limit));
+  }
+
+  async search(query: string, limit: number): Promise<JmapEmailView[]> {
+    const session = await this.ensureSession();
+    return this.views(buildSearchRequest(session.accountId, query, limit));
+  }
+
+  async get(id: string): Promise<JmapEmailView | null> {
+    const session = await this.ensureSession();
+    const views = await this.views(buildGetRequest(session.accountId, id));
+    return views[0] ?? null;
+  }
+
+  async send(input: SendMailInput): Promise<SendMailResult> {
+    const session = await this.ensureSession();
+    const { accountId } = session;
+
+    // Round 1: discover the sending identity + the Drafts mailbox.
+    const discovery = await this.api({
+      using: [CORE_CAPABILITY, MAIL_CAPABILITY, SUBMISSION_CAPABILITY],
+      methodCalls: [
+        ["Identity/get", { accountId, ids: null }, "id"],
+        ["Mailbox/query", { accountId, filter: { role: "drafts" } }, "mq"],
+      ],
+    });
+    const identities = methodResponseArgs(discovery, "Identity/get")?.["list"];
+    const identity = Array.isArray(identities) ? asRecord(identities[0]) : null;
+    const identityId = identity === null ? null : asString(identity["id"]);
+    const identityEmail = identity === null ? null : asString(identity["email"]);
+    const mqIds = methodResponseArgs(discovery, "Mailbox/query")?.["ids"];
+    const draftMailboxId = Array.isArray(mqIds) ? asString(mqIds[0]) : null;
+    if (identityId === null || identityEmail === null || draftMailboxId === null) {
+      throw new Error("JMAP send: could not resolve sending identity or Drafts mailbox");
+    }
+
+    // Round 2: create the draft email + submit it.
+    const created = await this.api({
+      using: [CORE_CAPABILITY, MAIL_CAPABILITY, SUBMISSION_CAPABILITY],
+      methodCalls: [
+        [
+          "Email/set",
+          {
+            accountId,
+            create: {
+              draft: {
+                mailboxIds: { [draftMailboxId]: true },
+                keywords: { $draft: true, $seen: true },
+                from: [{ email: identityEmail }],
+                to: parseAddressList(input.to),
+                ...(input.cc === undefined ? {} : { cc: parseAddressList(input.cc) }),
+                ...(input.bcc === undefined ? {} : { bcc: parseAddressList(input.bcc) }),
+                subject: input.subject,
+                bodyStructure: { type: "text/plain", partId: "b" },
+                bodyValues: { b: { value: input.body } },
+              },
+            },
+          },
+          "es",
+        ],
+        [
+          "EmailSubmission/set",
+          {
+            accountId,
+            create: { sub: { emailId: "#draft", identityId } },
+          },
+          "sub",
+        ],
+      ],
+    });
+    const emailCreated = asRecord(methodResponseArgs(created, "Email/set")?.["created"]);
+    const emailId =
+      emailCreated === null ? null : asString(asRecord(emailCreated["draft"])?.["id"]);
+    const subCreated = asRecord(methodResponseArgs(created, "EmailSubmission/set")?.["created"]);
+    const submissionId = subCreated === null ? null : asString(asRecord(subCreated["sub"])?.["id"]);
+    return { emailId, submissionId };
+  }
+}
+
+/** The client the entry point uses. Credentials are read at construction. */
+export function createFetchJmapClient(): JmapClient {
+  return new FetchJmapClient();
+}
+
+export { parseAddressList };