@nimbus-dev/connectors 0.2.1 → 0.2.2

package/connectors/outlook/src/tools.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+import { type ConsentServer, createWriteToolRegistrar } from "../../../shared/consent-kit.ts";
+import { headerLine } from "../../../shared/header-safe.ts";
+import { mailSendConsent } from "../../../shared/imap-tool-kit.ts";
+import {
+  createRegisterSimpleTool,
+  createZodToolRegistrar,
+  mcpJsonResult,
+  requireProcessEnv,
+} from "../../../shared/mcp-tool-kit.ts";
+import {
+  makeRestFetcher,
+  makeRestToolRegistrar,
+  makeRestWriteToolRegistrar,
+} from "../../../shared/rest-tool-kit.ts";
+import {
+  outlookToolShouldRegister,
+  parseMicrosoftOAuthScopesFromEnv,
+} from "./tool-scope-policy.ts";
+
+/**
+ * nimbus-connector outlook — Microsoft Graph mail, calendar, contacts (read + guarded writes).
+ * Access token is injected as MICROSOFT_OAUTH_ACCESS_TOKEN (never logged).
+ * Optional `MICROSOFT_OAUTH_SCOPES` (space-separated) gates which tools register; the Gateway
+ * audit-ignore-next-line D11-vault-key (JSDoc reference, not vault-key construction)
+ * sets it from `microsoft.oauth` JSON when `scopes` is present.
+ * Send / calendar mutations require Gateway HITL (email.send, calendar.event.create | delete).
+ */
+
+const GRAPH = "https://graph.microsoft.com/v1.0";
+
+function graphRequest(
+  token: string,
+  pathOrUrl: string,
+  init?: RequestInit,
+): Promise<{ ok: boolean; status: number; json: unknown; text: string }> {
+  return makeRestFetcher({ apiBase: GRAPH, token })(pathOrUrl, init);
+}
+
+/** Tool names exposed by this connector — for contract/introspection tests. */
+export const OUTLOOK_TOOL_NAMES = [
+  "outlook_mail_folders",
+  "outlook_mail_list",
+  "outlook_mail_read",
+  "outlook_mail_send",
+  "outlook_calendar_list",
+  "outlook_calendar_get",
+  "outlook_calendar_create",
+  "outlook_calendar_delete",
+  "outlook_contact_list",
+  "outlook_contact_get",
+] as const;
+
+export function registerOutlookTools(
+  server: ConsentServer & { tool: (...args: never) => unknown },
+): void {
+  const reg = createZodToolRegistrar(createRegisterSimpleTool(server));
+  const grantedOutlookScopes = parseMicrosoftOAuthScopesFromEnv();
+
+  /**
+   * Every MUTATING outlook tool goes through here. Outside the gateway this adds the
+   * consent gate, the write-scope allow-list, the mutation budget and the audit record; inside
+   * the gateway it is a pass-through, because executor.ts (I2) is the gate there.
+   */
+  const registerWriteTool = createWriteToolRegistrar(server, {
+    connector: "outlook",
+    scopeEnv: "NIMBUS_MCP_OUTLOOK_WRITE_SCOPE",
+    scopeKinds: ["recipient", "calendar"],
+  });
+
+  /**
+   * Standard Graph tool, read or write: token → graphRequest(buildPath[, buildInit]) →
+   * mcpJsonResultIfOk("Graph", …, 200).
+   */
+  const graphRest = {
+    tokenEnv: "MICROSOFT_OAUTH_ACCESS_TOKEN",
+    serviceLabel: "Graph",
+    fetch: graphRequest,
+    snippetMax: 200,
+  } as const;
+
+  /** The write-tool equivalent of `registerOutlookTool`, routed through the write registrar. */
+  const registerOutlookWriteTool = makeRestWriteToolRegistrar({ registerWriteTool, ...graphRest });
+  const registerOutlookTool = makeRestToolRegistrar({ registrar: reg, ...graphRest });
+
+  const outlookMailFoldersArgs = z.object({
+    top: z.number().int().min(1).max(200).optional(),
+    nextLink: z.url().optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_mail_folders", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_mail_folders",
+      "List mail folders (pagination via nextLink).",
+      outlookMailFoldersArgs,
+      (data) => {
+        if (data.nextLink !== undefined && data.nextLink !== "") {
+          return data.nextLink;
+        }
+        const top = data.top ?? 50;
+        return `/me/mailFolders?$top=${String(top)}`;
+      },
+    );
+  }
+
+  const outlookMailListArgs = z.object({
+    folderId: z.string().min(1).optional(),
+    top: z.number().int().min(1).max(100).optional(),
+    skip: z.number().int().min(0).optional(),
+    nextLink: z.url().optional(),
+    filter: z.string().max(500).optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_mail_list", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_mail_list",
+      "List mail messages (default folder inbox if folderId omitted). Pagination via nextLink.",
+      outlookMailListArgs,
+      (data) => {
+        if (data.nextLink !== undefined && data.nextLink !== "") {
+          return data.nextLink;
+        }
+        const top = data.top ?? 25;
+        const fid = data.folderId !== undefined && data.folderId !== "" ? data.folderId : "inbox";
+        const skip = data.skip ?? 0;
+        const path = `/me/mailFolders/${encodeURIComponent(fid)}/messages`;
+        const u = new URL(`${GRAPH}${path}`);
+        u.searchParams.set("$top", String(top));
+        u.searchParams.set("$skip", String(skip));
+        u.searchParams.set(
+          "$select",
+          "id,subject,bodyPreview,receivedDateTime,lastModifiedDateTime,hasAttachments,webLink",
+        );
+        if (data.filter !== undefined && data.filter !== "") {
+          u.searchParams.set("$filter", data.filter);
+        }
+        // Relative to GRAPH, like every other tool here: the fetcher prefixes the base, which
+        // already ends in /v1.0, so returning `u.pathname` requested /v1.0/v1.0/me/….
+        return `${path}${u.search}`;
+      },
+    );
+  }
+
+  const outlookMailReadArgs = z.object({
+    messageId: z.string().min(1),
+  });
+
+  if (outlookToolShouldRegister("outlook_mail_read", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_mail_read",
+      "Read a single message (body, headers, attachments metadata).",
+      outlookMailReadArgs,
+      (data) => `/me/messages/${encodeURIComponent(data.messageId)}?$expand=attachments`,
+    );
+  }
+
+  const outlookMailSendArgs = z.object({
+    to: headerLine({ min: 1, max: 2000 }),
+    subject: headerLine({ min: 1, max: 500 }),
+    body: z.string().min(1).max(1_000_000),
+    contentType: z.enum(["text", "html"]).optional(),
+    cc: headerLine({ max: 2000 }).optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_mail_send", grantedOutlookScopes)) {
+    registerWriteTool(
+      "outlook_mail_send",
+      mailSendConsent("outlook.mail.send"),
+      "Send an email via Microsoft Graph. Requires Gateway HITL email.send.",
+      outlookMailSendArgs,
+      async (data) => {
+        const token = requireProcessEnv("MICROSOFT_OAUTH_ACCESS_TOKEN");
+        const toList = data.to
+          .split(",")
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0);
+        const message: Record<string, unknown> = {
+          subject: data.subject,
+          body: {
+            contentType: (data.contentType ?? "text") === "html" ? "HTML" : "Text",
+            content: data.body,
+          },
+          toRecipients: toList.map((addr) => ({
+            emailAddress: { address: addr },
+          })),
+        };
+        if (data.cc !== undefined && data.cc !== "") {
+          const ccList = data.cc
+            .split(",")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+          message["ccRecipients"] = ccList.map((addr) => ({
+            emailAddress: { address: addr },
+          }));
+        }
+        const r = await graphRequest(token, "/me/sendMail", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ message, saveToSentItems: true }),
+        });
+        if (!r.ok) {
+          throw new Error(`Graph ${String(r.status)}: ${r.text.slice(0, 200)}`);
+        }
+        return mcpJsonResult({ ok: true });
+      },
+    );
+  }
+
+  const outlookCalendarListArgs = z.object({
+    startDateTime: z.string().min(1),
+    endDateTime: z.string().min(1),
+    top: z.number().int().min(1).max(200).optional(),
+    nextLink: z.url().optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_calendar_list", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_calendar_list",
+      "List calendar events in a time window (ISO 8601 startDateTime / endDateTime).",
+      outlookCalendarListArgs,
+      (data) => {
+        if (data.nextLink !== undefined && data.nextLink !== "") {
+          return data.nextLink;
+        }
+        const top = data.top ?? 50;
+        const s = encodeURIComponent(data.startDateTime);
+        const e = encodeURIComponent(data.endDateTime);
+        return `/me/calendarView?startDateTime=${s}&endDateTime=${e}&$top=${String(top)}`;
+      },
+    );
+  }
+
+  const outlookCalendarGetArgs = z.object({
+    eventId: z.string().min(1),
+  });
+
+  if (outlookToolShouldRegister("outlook_calendar_get", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_calendar_get",
+      "Get a single calendar event by id.",
+      outlookCalendarGetArgs,
+      (data) => `/me/events/${encodeURIComponent(data.eventId)}`,
+    );
+  }
+
+  const outlookCalendarCreateArgs = z.object({
+    subject: headerLine({ min: 1, max: 500 }),
+    startDateTime: z.string().min(1),
+    endDateTime: z.string().min(1),
+    timeZone: z.string().min(1).max(100).optional(),
+    body: z.string().max(50_000).optional(),
+    attendees: headerLine({ max: 4000 }).optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_calendar_create", grantedOutlookScopes)) {
+    registerOutlookWriteTool(
+      "outlook_calendar_create",
+      {
+        mutates: "outlook.calendar.create",
+        recoverable: true,
+        scopeTargetOf: (p) => ({ kind: "calendar", value: p.subject }),
+      },
+      "Create a calendar event. Requires Gateway HITL calendar.event.create.",
+      outlookCalendarCreateArgs,
+      () => "/me/events",
+      (data) => {
+        const tz = data.timeZone ?? "UTC";
+        const body: Record<string, unknown> = {
+          subject: data.subject,
+          start: { dateTime: data.startDateTime, timeZone: tz },
+          end: { dateTime: data.endDateTime, timeZone: tz },
+        };
+        if (data.body !== undefined && data.body !== "") {
+          body["body"] = { contentType: "Text", content: data.body };
+        }
+        if (data.attendees !== undefined && data.attendees !== "") {
+          const addrs = data.attendees
+            .split(",")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+          body["attendees"] = addrs.map((a) => ({
+            emailAddress: { address: a },
+            type: "required",
+          }));
+        }
+        return {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+        };
+      },
+    );
+  }
+
+  const outlookCalendarDeleteArgs = z.object({
+    eventId: z.string().min(1),
+  });
+
+  if (outlookToolShouldRegister("outlook_calendar_delete", grantedOutlookScopes)) {
+    registerWriteTool(
+      "outlook_calendar_delete",
+      {
+        mutates: "outlook.calendar.delete",
+        recoverable: false,
+        capturePreState: (p) => Promise.resolve({ eventId: p.eventId }),
+        scopeTargetOf: (p) => ({ kind: "calendar", value: p.eventId }),
+      },
+      "Delete a calendar event. Requires Gateway HITL calendar.event.delete.",
+      outlookCalendarDeleteArgs,
+      async (data) => {
+        const token = requireProcessEnv("MICROSOFT_OAUTH_ACCESS_TOKEN");
+        const r = await graphRequest(token, `/me/events/${encodeURIComponent(data.eventId)}`, {
+          method: "DELETE",
+        });
+        if (!r.ok && r.status !== 204) {
+          throw new Error(`Graph ${String(r.status)}: ${r.text.slice(0, 200)}`);
+        }
+        return mcpJsonResult({ ok: true });
+      },
+    );
+  }
+
+  const outlookContactListArgs = z.object({
+    top: z.number().int().min(1).max(200).optional(),
+    skip: z.number().int().min(0).optional(),
+    nextLink: z.url().optional(),
+  });
+
+  if (outlookToolShouldRegister("outlook_contact_list", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_contact_list",
+      "List contacts from the default folder.",
+      outlookContactListArgs,
+      (data) => {
+        if (data.nextLink !== undefined && data.nextLink !== "") {
+          return data.nextLink;
+        }
+        const top = data.top ?? 50;
+        const skip = data.skip ?? 0;
+        return `/me/contacts?$top=${String(top)}&$skip=${String(skip)}`;
+      },
+    );
+  }
+
+  const outlookContactGetArgs = z.object({
+    contactId: z.string().min(1),
+  });
+
+  if (outlookToolShouldRegister("outlook_contact_get", grantedOutlookScopes)) {
+    registerOutlookTool(
+      "outlook_contact_get",
+      "Get a single contact by id.",
+      outlookContactGetArgs,
+      (data) => `/me/contacts/${encodeURIComponent(data.contactId)}`,
+    );
+  }
+}

package/connectors/pagerduty/src/server.ts

@@ -1,140 +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,
-  mcpJsonResult as jsonResult,
-  requireProcessEnv,
-} from "../../../shared/mcp-tool-kit.ts";
-import { makeRestToolRegistrar } from "../../../shared/rest-tool-kit.ts";
-
-const API = "https://api.pagerduty.com";
-
-async function pdFetch(
-  token: string,
-  path: string,
-  init?: RequestInit,
-): Promise<{ ok: boolean; status: number; json: unknown; text: string }> {
-  const rel = path.startsWith("/") ? path : `/${path}`;
-  const url = path.startsWith("http") ? path : `${API}${rel}`;
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Accept: "application/vnd.pagerduty+json;version=2",
-      Authorization: `Token token=${token}`,
-      "Content-Type": "application/json",
-      ...(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 };
-}
-
-async function pdIncidentPutMutation(actionLabel: string, pathSuffix: string, incidentId: string) {
-  const token = requireProcessEnv("PAGERDUTY_API_TOKEN");
-  const res = await pdFetch(token, `/incidents/${encodeURIComponent(incidentId)}/${pathSuffix}`, {
-    method: "PUT",
-    body: JSON.stringify({ incident: { type: "incident_reference", id: incidentId } }),
-  });
-  if (!res.ok) {
-    throw new Error(`PagerDuty ${actionLabel} ${String(res.status)}: ${res.text.slice(0, 400)}`);
-  }
-  return jsonResult(res.json ?? { ok: true });
-}
+import { registerPagerdutyTools } from "./tools.ts";
 
 const mcp = new McpServer({ name: "nimbus-pagerduty", version: "0.1.0" });
 
-import { createWriteToolRegistrar } from "../../../shared/consent-kit.ts";
-
-const reg = createZodToolRegistrar(createRegisterSimpleTool(mcp));
-
-/**
- * Every MUTATING pagerduty tool goes through here. Outside the gateway this adds the
- * consent gate, the write-scope allow-list, the mutation budget and the audit record; inside
- * the gateway it is a pass-through, because executor.ts (I2) is the gate there.
- */
-const registerWriteTool = createWriteToolRegistrar(mcp, {
-  connector: "pagerduty",
-  scopeEnv: "NIMBUS_MCP_PAGERDUTY_WRITE_SCOPE",
-  scopeKinds: ["incident"],
-});
-
-/** Standard PagerDuty read tool: token → pdFetch(buildPath) → mcpJsonResultIfOk("PagerDuty"). */
-const registerPdTool = makeRestToolRegistrar({
-  registrar: reg,
-  tokenEnv: "PAGERDUTY_API_TOKEN",
-  serviceLabel: "PagerDuty",
-  fetch: pdFetch,
-});
-
-registerPdTool(
-  "pd_incident_list",
-  "List PagerDuty incidents (open and recently resolved).",
-  z.object({
-    statuses: z.array(z.enum(["triggered", "acknowledged", "resolved"])).optional(),
-    limit: z.number().int().min(1).max(100).optional(),
-  }),
-  (parsed) => {
-    const u = new URL(`${API}/incidents`);
-    u.searchParams.set("limit", String(parsed.limit ?? 25));
-    const st = parsed.statuses ?? ["triggered", "acknowledged"];
-    for (const s of st) {
-      u.searchParams.append("statuses[]", s);
-    }
-    return `${u.pathname}${u.search}`;
-  },
-);
-
-registerPdTool(
-  "pd_incident_get",
-  "Get a single incident by id.",
-  z.object({ incidentId: z.string().min(1) }),
-  (parsed) => `/incidents/${encodeURIComponent(parsed.incidentId)}`,
-);
-
-registerWriteTool(
-  "pd_incident_acknowledge",
-  {
-    mutates: "pagerduty.incident.acknowledge",
-    recoverable: true,
-    scopeTargetOf: (p) => ({ kind: "incident", value: p.incidentId }),
-  },
-  "Acknowledge an incident.",
-  z.object({ incidentId: z.string().min(1) }),
-  async (parsed) => pdIncidentPutMutation("acknowledge", "acknowledge", parsed.incidentId),
-);
-
-registerWriteTool(
-  "pd_incident_resolve",
-  {
-    mutates: "pagerduty.incident.resolve",
-    recoverable: true,
-    scopeTargetOf: (p) => ({ kind: "incident", value: p.incidentId }),
-  },
-  "Resolve an incident.",
-  z.object({ incidentId: z.string().min(1) }),
-  async (parsed) => pdIncidentPutMutation("resolve", "resolve", parsed.incidentId),
-);
-
-registerWriteTool(
-  "pd_incident_escalate",
-  {
-    mutates: "pagerduty.incident.escalate",
-    recoverable: true,
-    scopeTargetOf: (p) => ({ kind: "incident", value: p.incidentId }),
-  },
-  "Escalate an incident.",
-  z.object({ incidentId: z.string().min(1) }),
-  async (parsed) => pdIncidentPutMutation("escalate", "escalate", parsed.incidentId),
-);
+registerPagerdutyTools(mcp);
 
 const transport = new StdioServerTransport();
 await mcp.connect(transport);

package/connectors/pagerduty/src/tools.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import type { ConsentServer } from "../../../shared/consent-kit.ts";
+import { createWriteToolRegistrar } from "../../../shared/consent-kit.ts";
+import {
+  createRegisterSimpleTool,
+  createZodToolRegistrar,
+  mcpJsonResult as jsonResult,
+  requireProcessEnv,
+} from "../../../shared/mcp-tool-kit.ts";
+import {
+  makeRestToolRegistrar,
+  type RestFetchResult,
+  toRestFetchResult,
+} from "../../../shared/rest-tool-kit.ts";
+
+const API = "https://api.pagerduty.com";
+
+async function pdFetch(token: string, path: string, init?: RequestInit): Promise<RestFetchResult> {
+  const rel = path.startsWith("/") ? path : `/${path}`;
+  const url = path.startsWith("http") ? path : `${API}${rel}`;
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      Accept: "application/vnd.pagerduty+json;version=2",
+      Authorization: `Token token=${token}`,
+      "Content-Type": "application/json",
+      ...(init?.headers as Record<string, string> | undefined),
+    },
+  });
+  return toRestFetchResult(res);
+}
+
+async function pdIncidentPutMutation(actionLabel: string, pathSuffix: string, incidentId: string) {
+  const token = requireProcessEnv("PAGERDUTY_API_TOKEN");
+  const res = await pdFetch(token, `/incidents/${encodeURIComponent(incidentId)}/${pathSuffix}`, {
+    method: "PUT",
+    body: JSON.stringify({ incident: { type: "incident_reference", id: incidentId } }),
+  });
+  if (!res.ok) {
+    throw new Error(`PagerDuty ${actionLabel} ${String(res.status)}: ${res.text.slice(0, 400)}`);
+  }
+  return jsonResult(res.json ?? { ok: true });
+}
+
+/** Tool names exposed by this connector — for contract/introspection tests. */
+export const PAGERDUTY_TOOL_NAMES = [
+  "pd_incident_list",
+  "pd_incident_get",
+  "pd_incident_acknowledge",
+  "pd_incident_resolve",
+  "pd_incident_escalate",
+] as const;
+
+/** The incident status changes, which differ only in the word they PUT. */
+const INCIDENT_STATUS_ACTIONS = [
+  { action: "acknowledge", description: "Acknowledge an incident." },
+  { action: "resolve", description: "Resolve an incident." },
+  { action: "escalate", description: "Escalate an incident." },
+] as const;
+
+export function registerPagerdutyTools(
+  server: ConsentServer & { tool: (...args: never) => unknown },
+): void {
+  const reg = createZodToolRegistrar(createRegisterSimpleTool(server));
+
+  /**
+   * Every MUTATING pagerduty tool goes through here. Outside the gateway this adds the
+   * consent gate, the write-scope allow-list, the mutation budget and the audit record; inside
+   * the gateway it is a pass-through, because executor.ts (I2) is the gate there.
+   */
+  const registerWriteTool = createWriteToolRegistrar(server, {
+    connector: "pagerduty",
+    scopeEnv: "NIMBUS_MCP_PAGERDUTY_WRITE_SCOPE",
+    scopeKinds: ["incident"],
+  });
+
+  /** Standard PagerDuty read tool: token → pdFetch(buildPath) → mcpJsonResultIfOk("PagerDuty"). */
+  const registerPdTool = makeRestToolRegistrar({
+    registrar: reg,
+    tokenEnv: "PAGERDUTY_API_TOKEN",
+    serviceLabel: "PagerDuty",
+    fetch: pdFetch,
+  });
+
+  registerPdTool(
+    "pd_incident_list",
+    "List PagerDuty incidents (open and recently resolved).",
+    z.object({
+      statuses: z.array(z.enum(["triggered", "acknowledged", "resolved"])).optional(),
+      limit: z.number().int().min(1).max(100).optional(),
+    }),
+    (parsed) => {
+      const u = new URL(`${API}/incidents`);
+      u.searchParams.set("limit", String(parsed.limit ?? 25));
+      const st = parsed.statuses ?? ["triggered", "acknowledged"];
+      for (const s of st) {
+        u.searchParams.append("statuses[]", s);
+      }
+      return `${u.pathname}${u.search}`;
+    },
+  );
+
+  registerPdTool(
+    "pd_incident_get",
+    "Get a single incident by id.",
+    z.object({ incidentId: z.string().min(1) }),
+    (parsed) => `/incidents/${encodeURIComponent(parsed.incidentId)}`,
+  );
+
+  // The three incident status changes are the same PUT with a different status
+  // word, so they are declared rather than written out three times. Each keeps
+  // its own description; the rest was identical.
+  for (const { action, description } of INCIDENT_STATUS_ACTIONS) {
+    registerWriteTool(
+      `pd_incident_${action}`,
+      {
+        mutates: `pagerduty.incident.${action}`,
+        recoverable: true,
+        scopeTargetOf: (p) => ({ kind: "incident", value: p.incidentId }),
+      },
+      description,
+      z.object({ incidentId: z.string().min(1) }),
+      async (parsed) => pdIncidentPutMutation(action, action, parsed.incidentId),
+    );
+  }
+}

package/connectors/pipedrive/src/server.ts

@@ -1,62 +1,6 @@
-import { z } from "zod";
-import { matchesResult, 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 { filterPipedriveDeals } from "./search-filter.ts";
-
-const BASE = "https://api.pipedrive.com";
-
-function apiToken(): string {
-  const t = process.env["PIPEDRIVE_TOKEN"]?.trim();
-  if (t === undefined || t === "") {
-    throw new Error("PIPEDRIVE_TOKEN is not set");
-  }
-  return t;
-}
-
-function withToken(path: string): string {
-  const sep = path.includes("?") ? "&" : "?";
-  return `${BASE}${path}${sep}api_token=${encodeURIComponent(apiToken())}`;
-}
-
-async function pipedriveGet(path: string, resourceLabel: string): Promise<unknown> {
-  const res = await fetch(withToken(path), { headers: { Accept: "application/json" } });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`Pipedrive ${resourceLabel} ${String(res.status)}: ${text.slice(0, 400)}`);
-  }
-  return JSON.parse(text) as unknown;
-}
+import { registerPipedriveTools } from "./tools.ts";
 
 await runReadOnlyMcpConnector("nimbus-pipedrive", (reg) => {
-  reg(
-    "pipedrive_list",
-    "List the user's Pipedrive deals (`GET /v1/deals?limit=100`). Returns the `{ success, data: [...], additional_data: { pagination } }` envelope — `data` holds the deal objects (and may be null when there are no deals).",
-    z.object({}),
-    async () => {
-      return jsonResult(await pipedriveGet(`/v1/deals?limit=100`, "deals"));
-    },
-  );
-
-  reg(
-    "pipedrive_get",
-    "Fetch one Pipedrive deal by its id (`GET /v1/deals/{id}`). Returns the `{ success, data: {...} }` envelope. Throws when no match is found.",
-    z.object({
-      id: z.string().min(1),
-    }),
-    async (p) => {
-      return jsonResult(await pipedriveGet(`/v1/deals/${encodeURIComponent(p.id)}`, "deal"));
-    },
-  );
-
-  reg(
-    "pipedrive_search",
-    "Substring search across the user's Pipedrive deals (first page only). Matches the query against the deal title, status, organization name, person name, owner name, and label (case-insensitive). Returns a `{ matches: [...] }` envelope.",
-    searchToolInputSchema(100),
-    async (p) => {
-      const root = await pipedriveGet(`/v1/deals?limit=100`, "deals");
-      const data = (root as { data?: unknown } | null)?.data;
-      return matchesResult(data, filterPipedriveDeals, p);
-    },
-  );
+  registerPipedriveTools(reg);
 });