@orbitlogistics/mcp-plain 0.1.0

package/dist/index.js

@@ -0,0 +1,2096 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/threads.ts
+import { ThreadStatus, ThreadFieldSchemaType } from "@team-plain/typescript-sdk";
+
+// src/client.ts
+import { PlainClient } from "@team-plain/typescript-sdk";
+var client = null;
+var getPlainClient = () => {
+  if (client) {
+    return client;
+  }
+  const apiKey = process.env.PLAIN_API_KEY;
+  if (!apiKey) {
+    throw new Error("PLAIN_API_KEY environment variable is required");
+  }
+  client = new PlainClient({ apiKey });
+  return client;
+};
+
+// src/types.ts
+import { z } from "zod";
+var IMPACT_LEVELS = [
+  "P0",
+  "P1",
+  "P2",
+  "RBS",
+  "RBP",
+  "not-a-bug"
+];
+var FIELD_KEY_MAP = {
+  impact_level: "impactLevel",
+  notion_ticket: "notionTicket",
+  posthog_session: "posthogSession",
+  github_pr: "githubPr",
+  tenant_id: "tenant",
+  app: "affectedApp",
+  reported_from: "reportedFromUrl",
+  stage: "affectedStage",
+  request_feature: "requestFeature",
+  sentry_session: "sentrySession"
+};
+var listThreadsInputSchema = z.object({
+  statuses: z.array(z.string()).optional().describe("Filter by thread statuses (e.g., 'TODO', 'DONE', 'SNOOZED')"),
+  priority: z.number().min(0).max(3).optional().describe("Filter by priority (0 = urgent, 3 = low)"),
+  labelTypeIds: z.array(z.string()).optional().describe("Filter by label type IDs"),
+  customerId: z.string().optional().describe("Filter by customer ID"),
+  tenantId: z.string().optional().describe("Filter by tenant ID (via thread field)"),
+  first: z.number().min(1).max(100).default(50).optional().describe("Number of threads to return (default 50, max 100)"),
+  after: z.string().optional().describe("Cursor for pagination")
+});
+var getThreadInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to retrieve")
+});
+var getThreadFieldsInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to get fields for")
+});
+var getThreadByRefInputSchema = z.object({
+  ref: z.string().describe("Thread reference number (e.g., 'T-510')")
+});
+var getAttachmentDownloadUrlInputSchema = z.object({
+  attachmentId: z.string().describe("The ID of the attachment to get a download URL for")
+});
+var getAttachmentContentInputSchema = z.object({
+  attachmentId: z.string().describe("The ID of the attachment to fetch content for")
+});
+var upsertThreadFieldInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to update"),
+  key: z.string().describe(
+    "Custom field key in snake_case, e.g. impact_level, app, stage, tenant_id, notion_ticket, github_pr, posthog_session, sentry_session, reported_from, request_feature"
+  ),
+  value: z.string().describe("Field value to set. For boolean fields like request_feature, use 'true' or 'false'")
+});
+var addInternalNoteInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to add a note to"),
+  markdown: z.string().describe("Markdown content for the internal note")
+});
+var replyToThreadInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to reply to"),
+  textContent: z.string().describe("Plain text content of the reply"),
+  markdownContent: z.string().optional().describe("Optional markdown-formatted content of the reply")
+});
+var markThreadAsDoneInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to mark as done")
+});
+var addLabelsInputSchema = z.object({
+  threadId: z.string().describe("The ID of the thread to add labels to"),
+  labelTypeIds: z.array(z.string()).describe(
+    "Array of label type IDs to add. Use get_label_types first to discover available label type IDs."
+  )
+});
+var getLabelTypesInputSchema = z.object({
+  first: z.number().min(1).max(100).optional().describe("Number of label types to return (default 50)")
+});
+var createThreadInputSchema = z.object({
+  customerEmail: z.string().optional().describe("Customer email address. Provide either customerEmail, customerId, or customerExternalId."),
+  customerId: z.string().optional().describe("Existing Plain customer ID. Provide either customerEmail, customerId, or customerExternalId."),
+  customerExternalId: z.string().optional().describe("Customer external ID. Provide either customerEmail, customerId, or customerExternalId."),
+  customerFullName: z.string().optional().describe("Customer full name. Used when upserting a customer by email (ignored when customerId is provided)."),
+  title: z.string().optional().describe("Thread title"),
+  description: z.string().optional().describe("Thread description / preview text"),
+  markdown: z.string().describe("Markdown content for the first timeline entry in the thread"),
+  priority: z.number().min(0).max(3).optional().describe("Priority: 0 = urgent, 1 = high, 2 = normal (default), 3 = low"),
+  labelTypeIds: z.array(z.string()).optional().describe("Label type IDs to attach. Use get_label_types to discover available IDs."),
+  externalId: z.string().optional().describe("Your own unique identifier for this thread"),
+  // Custom thread fields (Plain snake_case keys)
+  impactLevel: z.enum(["P0", "P1", "P2", "RBS", "RBP", "not-a-bug"]).optional().describe("Impact level: P0 (critical), P1, P2, RBS (release blocker staging), RBP (release blocker production), not-a-bug"),
+  app: z.string().optional().describe("Affected app identifier (e.g. 'web', 'mobile', 'api')"),
+  tenantId: z.string().optional().describe("Tenant ID to associate with the thread"),
+  stage: z.string().optional().describe("Environment stage (e.g. 'production', 'staging', 'develop')"),
+  reportedFrom: z.string().optional().describe("URL where the issue was reported from"),
+  posthogSession: z.string().optional().describe("PostHog session replay URL or session recording ID"),
+  sentrySession: z.string().optional().describe("Sentry replay URL or replay ID"),
+  notionTicket: z.string().optional().describe("Notion ticket URL or ID"),
+  githubPr: z.string().optional().describe("GitHub PR URL"),
+  requestFeature: z.boolean().optional().describe("Whether this is a feature request")
+});
+var listHelpCentersInputSchema = z.object({});
+var getHelpCenterInputSchema = z.object({
+  helpCenterId: z.string().describe("The ID of the help center to retrieve")
+});
+var listHelpCenterArticlesInputSchema = z.object({
+  helpCenterId: z.string().describe("The ID of the help center to list articles from"),
+  first: z.number().min(1).max(100).optional().describe("Number of articles to return (default 20, max 100)")
+});
+var getHelpCenterArticleInputSchema = z.object({
+  helpCenterArticleId: z.string().describe("The ID of the help center article to retrieve")
+});
+var getHelpCenterArticleBySlugInputSchema = z.object({
+  helpCenterId: z.string().describe("The ID of the help center the article belongs to"),
+  slug: z.string().describe("The URL slug of the article")
+});
+var upsertHelpCenterArticleInputSchema = z.object({
+  helpCenterId: z.string().describe("The ID of the help center to create/update the article in"),
+  title: z.string().describe("Article title"),
+  contentHtml: z.string().describe("Article content as HTML (not markdown)"),
+  helpCenterArticleId: z.string().optional().describe("Existing article ID for updates. Omit to create a new article."),
+  description: z.string().describe("Short description / summary of the article"),
+  slug: z.string().optional().describe("URL slug for the article"),
+  helpCenterArticleGroupId: z.string().optional().describe("Article group ID to place the article in")
+});
+var createHelpCenterArticleGroupInputSchema = z.object({
+  helpCenterId: z.string().describe("The ID of the help center to create the group in"),
+  name: z.string().describe("Name of the article group"),
+  parentHelpCenterArticleGroupId: z.string().optional().describe("Parent group ID for nested groups")
+});
+var deleteHelpCenterArticleGroupInputSchema = z.object({
+  helpCenterArticleGroupId: z.string().describe("The ID of the article group to delete")
+});
+
+// src/tools/threads.ts
+var THREAD_QUERY = `
+  query GetThread($threadId: ID!) {
+    thread(threadId: $threadId) {
+      id
+      externalId
+      title
+      previewText
+      status
+      priority
+      customer {
+        id
+        fullName
+        email { email }
+        externalId
+      }
+      labels {
+        labelType {
+          id
+          name
+        }
+      }
+      threadFields {
+        key
+        stringValue
+        booleanValue
+      }
+      createdAt { iso8601 }
+      updatedAt { iso8601 }
+      timelineEntries(first: 50) {
+        edges {
+          node {
+            id
+            timestamp { iso8601 }
+            actor {
+              __typename
+              ... on UserActor { user { fullName } }
+              ... on CustomerActor { customer { fullName } }
+              ... on MachineUserActor { machineUser { fullName } }
+            }
+            entry {
+              __typename
+              ... on NoteEntry {
+                markdown
+              }
+              ... on EmailEntry {
+                subject
+                markdownContent
+                from { email name }
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on CustomEntry {
+                title
+                externalId
+                components {
+                  __typename
+                  ... on ComponentText {
+                    text
+                  }
+                  ... on ComponentPlainText {
+                    plainText
+                  }
+                }
+              }
+              ... on SlackMessageEntry {
+                text
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on SlackReplyEntry {
+                text
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on ThreadDiscussionEntry {
+                threadDiscussionId
+                discussionType
+                slackChannelName
+                slackMessageLink
+                emailRecipients
+              }
+              ... on ThreadDiscussionMessageEntry {
+                threadDiscussionId
+                threadDiscussionMessageId
+                discussionType
+                text
+                resolvedText
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on ThreadDiscussionResolvedEntry {
+                threadDiscussionId
+                discussionType
+                resolvedAt { iso8601 }
+                slackChannelName
+                slackMessageLink
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var THREAD_BY_REF_QUERY = `
+  query GetThreadByRef($ref: String!) {
+    threadByRef(ref: $ref) {
+      id
+      externalId
+      title
+      previewText
+      status
+      priority
+      customer {
+        id
+        fullName
+        email { email }
+        externalId
+      }
+      labels {
+        labelType {
+          id
+          name
+        }
+      }
+      threadFields {
+        key
+        stringValue
+        booleanValue
+      }
+      createdAt { iso8601 }
+      updatedAt { iso8601 }
+      timelineEntries(first: 50) {
+        edges {
+          node {
+            id
+            timestamp { iso8601 }
+            actor {
+              __typename
+              ... on UserActor { user { fullName } }
+              ... on CustomerActor { customer { fullName } }
+              ... on MachineUserActor { machineUser { fullName } }
+            }
+            entry {
+              __typename
+              ... on NoteEntry {
+                markdown
+              }
+              ... on EmailEntry {
+                subject
+                markdownContent
+                from { email name }
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on CustomEntry {
+                title
+                externalId
+                components {
+                  __typename
+                  ... on ComponentText {
+                    text
+                  }
+                  ... on ComponentPlainText {
+                    plainText
+                  }
+                }
+              }
+              ... on SlackMessageEntry {
+                text
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on SlackReplyEntry {
+                text
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on ThreadDiscussionEntry {
+                threadDiscussionId
+                discussionType
+                slackChannelName
+                slackMessageLink
+                emailRecipients
+              }
+              ... on ThreadDiscussionMessageEntry {
+                threadDiscussionId
+                threadDiscussionMessageId
+                discussionType
+                text
+                resolvedText
+                slackMessageLink
+                attachments {
+                  id
+                  fileName
+                  fileSize { kiloBytes }
+                  fileMimeType
+                }
+              }
+              ... on ThreadDiscussionResolvedEntry {
+                threadDiscussionId
+                discussionType
+                resolvedAt { iso8601 }
+                slackChannelName
+                slackMessageLink
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var mapStatus = (status) => {
+  const statusMap = {
+    TODO: ThreadStatus.Todo,
+    DONE: ThreadStatus.Done,
+    SNOOZED: ThreadStatus.Snoozed
+  };
+  return statusMap[status];
+};
+var parseThreadFields = (fields) => {
+  const result = {};
+  for (const field of fields) {
+    const mappedKey = FIELD_KEY_MAP[field.key];
+    if (!mappedKey) continue;
+    if (mappedKey === "requestFeature") {
+      result[mappedKey] = field.booleanValue ?? void 0;
+    } else if (mappedKey === "impactLevel") {
+      const value = field.stringValue;
+      if (value && IMPACT_LEVELS.includes(value)) {
+        result[mappedKey] = value;
+      }
+    } else {
+      result[mappedKey] = field.stringValue ?? void 0;
+    }
+  }
+  return result;
+};
+var extractCustomerInfo = (customer) => ({
+  id: customer.id,
+  email: customer.email?.email,
+  fullName: customer.fullName ?? void 0,
+  externalId: customer.externalId ?? void 0
+});
+var extractLabels = (labels) => labels.map((l) => ({
+  id: l.labelType.id,
+  name: l.labelType.name
+}));
+var extractActorName = (actor) => {
+  if (!actor) return void 0;
+  switch (actor.__typename) {
+    case "UserActor":
+      return actor.user?.fullName ?? void 0;
+    case "CustomerActor":
+      return actor.customer?.fullName ?? void 0;
+    case "MachineUserActor":
+      return actor.machineUser?.fullName ?? void 0;
+    default:
+      return void 0;
+  }
+};
+var parseAttachments = (attachments) => {
+  if (!attachments || attachments.length === 0) return void 0;
+  return attachments.map((att) => ({
+    id: att.id,
+    fileName: att.fileName,
+    fileSizeKb: att.fileSize?.kiloBytes ?? void 0,
+    mimeType: att.fileMimeType ?? void 0
+  }));
+};
+var parseTimelineEntry = (node) => {
+  const { id, timestamp, actor, entry } = node;
+  const baseEntry = {
+    id,
+    timestamp: timestamp?.iso8601 ?? ""
+  };
+  switch (entry.__typename) {
+    case "NoteEntry":
+      return {
+        ...baseEntry,
+        entryType: "NOTE",
+        text: entry.text || entry.markdown || "",
+        // fallback to markdown if text is empty
+        markdown: entry.markdown ?? void 0,
+        createdBy: actor ? { name: extractActorName(actor) } : void 0
+      };
+    case "EmailEntry":
+      return {
+        ...baseEntry,
+        entryType: "EMAIL",
+        subject: entry.subject ?? void 0,
+        textContent: entry.markdownContent || entry.textContent || void 0,
+        from: entry.from ? { email: entry.from.email, name: entry.from.name ?? void 0 } : void 0,
+        attachments: parseAttachments(entry.attachments)
+      };
+    case "ChatEntry":
+      return {
+        ...baseEntry,
+        entryType: "CHAT",
+        text: entry.text ?? "",
+        createdBy: actor ? {
+          name: extractActorName(actor),
+          type: actor.__typename === "CustomerActor" ? "customer" : "user"
+        } : void 0
+      };
+    case "CustomEntry": {
+      const componentTexts = entry.components?.map((c) => c.text || c.plainText).filter((t) => !!t) ?? [];
+      const content = componentTexts.length > 0 ? componentTexts.join("\n") : void 0;
+      return {
+        ...baseEntry,
+        entryType: "CUSTOM",
+        title: entry.title ?? void 0,
+        externalId: entry.externalId ?? void 0,
+        content
+      };
+    }
+    case "SlackMessageEntry":
+      return {
+        ...baseEntry,
+        entryType: "SLACK",
+        text: entry.text ?? "",
+        isReply: false,
+        slackMessageLink: entry.slackMessageLink ?? void 0,
+        attachments: parseAttachments(entry.attachments),
+        createdBy: actor ? { name: extractActorName(actor) } : void 0
+      };
+    case "SlackReplyEntry":
+      return {
+        ...baseEntry,
+        entryType: "SLACK",
+        text: entry.text ?? "",
+        isReply: true,
+        slackMessageLink: entry.slackMessageLink ?? void 0,
+        attachments: parseAttachments(entry.attachments),
+        createdBy: actor ? { name: extractActorName(actor) } : void 0
+      };
+    case "ThreadDiscussionEntry":
+      return {
+        ...baseEntry,
+        entryType: "DISCUSSION",
+        threadDiscussionId: entry.threadDiscussionId ?? "",
+        discussionType: entry.discussionType ?? "",
+        slackChannelName: entry.slackChannelName ?? void 0,
+        slackMessageLink: entry.slackMessageLink ?? void 0,
+        emailRecipients: entry.emailRecipients ?? void 0
+      };
+    case "ThreadDiscussionMessageEntry":
+      return {
+        ...baseEntry,
+        entryType: "DISCUSSION_MESSAGE",
+        threadDiscussionId: entry.threadDiscussionId ?? "",
+        threadDiscussionMessageId: entry.threadDiscussionMessageId ?? "",
+        discussionType: entry.discussionType ?? "",
+        text: entry.resolvedText || entry.text || "",
+        slackMessageLink: entry.slackMessageLink ?? void 0,
+        attachments: parseAttachments(entry.attachments),
+        createdBy: actor ? { name: extractActorName(actor) } : void 0
+      };
+    case "ThreadDiscussionResolvedEntry":
+      return {
+        ...baseEntry,
+        entryType: "DISCUSSION_RESOLVED",
+        threadDiscussionId: entry.threadDiscussionId ?? "",
+        discussionType: entry.discussionType ?? "",
+        resolvedAt: entry.resolvedAt?.iso8601 ?? "",
+        slackChannelName: entry.slackChannelName ?? void 0,
+        slackMessageLink: entry.slackMessageLink ?? void 0
+      };
+    default:
+      return {
+        ...baseEntry,
+        entryType: "UNKNOWN"
+      };
+  }
+};
+var listThreads = async (input) => {
+  const client2 = getPlainClient();
+  const statuses = input.statuses?.map(mapStatus).filter((s) => s !== void 0);
+  const result = await client2.getThreads({
+    filters: {
+      ...statuses && statuses.length > 0 ? { statuses } : {},
+      ...input.customerId ? { customerIds: [input.customerId] } : {},
+      ...input.labelTypeIds ? { labelTypeIds: input.labelTypeIds } : {}
+    },
+    first: input.first ?? 50,
+    ...input.after ? { after: input.after } : {}
+  });
+  if (result.error) {
+    throw new Error(`Failed to list threads: ${result.error.message}`);
+  }
+  const threads = result.data.threads.map((thread) => ({
+    id: thread.id,
+    title: thread.title ?? void 0,
+    status: thread.status,
+    priority: thread.priority,
+    customer: thread.customer ? extractCustomerInfo(thread.customer) : void 0,
+    labels: extractLabels(thread.labels),
+    createdAt: thread.createdAt.iso8601,
+    updatedAt: thread.updatedAt.iso8601
+  }));
+  const filteredThreads = input.priority !== void 0 ? threads.filter((t) => t.priority === input.priority) : threads;
+  let finalThreads = filteredThreads;
+  if (input.tenantId) {
+    const threadsWithTenant = await Promise.all(
+      filteredThreads.map(async (thread) => {
+        const fields = await getThreadFields({ threadId: thread.id });
+        return { thread, tenant: fields.tenant };
+      })
+    );
+    finalThreads = threadsWithTenant.filter((t) => t.tenant === input.tenantId).map((t) => t.thread);
+  }
+  return {
+    threads: finalThreads,
+    pageInfo: {
+      hasNextPage: result.data.pageInfo.hasNextPage,
+      hasPreviousPage: result.data.pageInfo.hasPreviousPage,
+      startCursor: result.data.pageInfo.startCursor ?? void 0,
+      endCursor: result.data.pageInfo.endCursor ?? void 0
+    }
+  };
+};
+var getThread = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: THREAD_QUERY,
+    variables: { threadId: input.threadId }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get thread: ${result.error.message}`);
+  }
+  const data = result.data;
+  const thread = data.thread;
+  if (!thread) {
+    throw new Error(`Thread not found: ${input.threadId}`);
+  }
+  const customFields = parseThreadFields(thread.threadFields ?? []);
+  const timeline = thread.timelineEntries?.edges.map((edge) => parseTimelineEntry(edge.node)).filter((entry) => {
+    if (entry.entryType === "CUSTOM" && entry.title?.toLowerCase().includes("autoresponse")) {
+      return false;
+    }
+    return true;
+  }) ?? [];
+  return {
+    id: thread.id,
+    title: thread.title ?? void 0,
+    description: thread.previewText ?? void 0,
+    status: thread.status,
+    priority: thread.priority,
+    externalId: thread.externalId ?? void 0,
+    customer: thread.customer ? extractCustomerInfo(thread.customer) : void 0,
+    labels: extractLabels(thread.labels),
+    createdAt: thread.createdAt.iso8601,
+    updatedAt: thread.updatedAt.iso8601,
+    customFields,
+    timeline
+  };
+};
+var getThreadByRef = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: THREAD_BY_REF_QUERY,
+    variables: { ref: input.ref }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get thread: ${result.error.message}`);
+  }
+  const data = result.data;
+  const thread = data.threadByRef;
+  if (!thread) {
+    throw new Error(`Thread not found: ${input.ref}`);
+  }
+  const customFields = parseThreadFields(thread.threadFields ?? []);
+  const timeline = thread.timelineEntries?.edges.map((edge) => parseTimelineEntry(edge.node)).filter((entry) => {
+    if (entry.entryType === "CUSTOM" && entry.title?.toLowerCase().includes("autoresponse")) {
+      return false;
+    }
+    return true;
+  }) ?? [];
+  return {
+    id: thread.id,
+    title: thread.title ?? void 0,
+    description: thread.previewText ?? void 0,
+    status: thread.status,
+    priority: thread.priority,
+    externalId: thread.externalId ?? void 0,
+    customer: thread.customer ? extractCustomerInfo(thread.customer) : void 0,
+    labels: extractLabels(thread.labels),
+    createdAt: thread.createdAt.iso8601,
+    updatedAt: thread.updatedAt.iso8601,
+    customFields,
+    timeline
+  };
+};
+var getThreadFields = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.getThread({ threadId: input.threadId });
+  if (result.error) {
+    throw new Error(`Failed to get thread fields: ${result.error.message}`);
+  }
+  const thread = result.data;
+  if (!thread) {
+    throw new Error(`Thread not found: ${input.threadId}`);
+  }
+  return parseThreadFields(thread.threadFields ?? []);
+};
+var CREATE_ATTACHMENT_DOWNLOAD_URL_MUTATION = `
+  mutation CreateAttachmentDownloadUrl($input: CreateAttachmentDownloadUrlInput!) {
+    createAttachmentDownloadUrl(input: $input) {
+      attachmentDownloadUrl {
+        downloadUrl
+        expiresAt { iso8601 }
+      }
+      error {
+        message
+        type
+        code
+      }
+    }
+  }
+`;
+var getAttachmentDownloadUrl = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: CREATE_ATTACHMENT_DOWNLOAD_URL_MUTATION,
+    variables: { input: { attachmentId: input.attachmentId } }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get attachment download URL: ${result.error.message}`);
+  }
+  const data = result.data;
+  const response = data.createAttachmentDownloadUrl;
+  if (response.error) {
+    throw new Error(`Failed to get attachment download URL: ${response.error.message}`);
+  }
+  if (!response.attachmentDownloadUrl) {
+    throw new Error("No download URL returned");
+  }
+  return {
+    downloadUrl: response.attachmentDownloadUrl.downloadUrl,
+    expiresAt: response.attachmentDownloadUrl.expiresAt.iso8601
+  };
+};
+var isTextMimeType = (mimeType) => {
+  if (!mimeType) return false;
+  if (mimeType.startsWith("text/")) return true;
+  const textApplicationTypes = [
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+    "application/x-yaml",
+    "application/yaml",
+    "application/x-sh",
+    "application/x-python",
+    "application/sql",
+    "application/graphql",
+    "application/ld+json",
+    "application/manifest+json"
+  ];
+  return textApplicationTypes.includes(mimeType);
+};
+var getAttachmentContent = async (input) => {
+  const { downloadUrl } = await getAttachmentDownloadUrl({ attachmentId: input.attachmentId });
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch attachment content: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") || void 0;
+  const isText = isTextMimeType(contentType);
+  if (isText) {
+    const text = await response.text();
+    return {
+      content: text,
+      mimeType: contentType,
+      encoding: "text"
+    };
+  } else {
+    const buffer = await response.arrayBuffer();
+    const base64 = Buffer.from(buffer).toString("base64");
+    return {
+      content: base64,
+      mimeType: contentType,
+      encoding: "base64"
+    };
+  }
+};
+var replyToThread = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.replyToThread({
+    threadId: input.threadId,
+    textContent: input.textContent,
+    ...input.markdownContent ? { markdownContent: input.markdownContent } : {}
+  });
+  if (result.error) {
+    throw new Error(`Failed to reply to thread: ${result.error.message}`);
+  }
+  return { success: true };
+};
+var markThreadAsDone = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.markThreadAsDone({
+    threadId: input.threadId
+  });
+  if (result.error) {
+    throw new Error(`Failed to mark thread as done: ${result.error.message}`);
+  }
+  return {
+    threadId: result.data.id,
+    status: result.data.status
+  };
+};
+var UPSERT_THREAD_FIELD_MUTATION = `
+  mutation UpsertThreadField($input: UpsertThreadFieldInput!) {
+    upsertThreadField(input: $input) {
+      threadField {
+        key
+        stringValue
+        booleanValue
+      }
+      error {
+        message
+        type
+        code
+      }
+    }
+  }
+`;
+var BOOLEAN_FIELD_KEYS = /* @__PURE__ */ new Set(["request_feature"]);
+var upsertThreadField = async (input) => {
+  const client2 = getPlainClient();
+  const isBoolean = BOOLEAN_FIELD_KEYS.has(input.key);
+  const threadField = isBoolean ? { key: input.key, booleanValue: input.value === "true" } : { key: input.key, stringValue: input.value };
+  const result = await client2.rawRequest({
+    query: UPSERT_THREAD_FIELD_MUTATION,
+    variables: { input: { threadId: input.threadId, threadField } }
+  });
+  if (result.error) {
+    throw new Error(`Failed to upsert thread field: ${result.error.message}`);
+  }
+  const data = result.data;
+  const response = data.upsertThreadField;
+  if (response.error) {
+    throw new Error(`Failed to upsert thread field: ${response.error.message}`);
+  }
+  return { success: true, key: input.key, value: input.value };
+};
+var CREATE_NOTE_MUTATION = `
+  mutation CreateNote($input: CreateNoteInput!) {
+    createNote(input: $input) {
+      note {
+        id
+      }
+      error {
+        message
+        type
+        code
+      }
+    }
+  }
+`;
+var addInternalNote = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: CREATE_NOTE_MUTATION,
+    variables: { input: { threadId: input.threadId, markdown: input.markdown } }
+  });
+  if (result.error) {
+    throw new Error(`Failed to add internal note: ${result.error.message}`);
+  }
+  const data = result.data;
+  const response = data.createNote;
+  if (response.error) {
+    throw new Error(`Failed to add internal note: ${response.error.message}`);
+  }
+  if (!response.note) {
+    throw new Error("No note returned from createNote mutation");
+  }
+  return { success: true, noteId: response.note.id };
+};
+var addLabelsToThread = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.addLabels({
+    threadId: input.threadId,
+    labelTypeIds: input.labelTypeIds
+  });
+  if (result.error) {
+    throw new Error(`Failed to add labels: ${result.error.message}`);
+  }
+  return { success: true, labelCount: input.labelTypeIds.length };
+};
+var getLabelTypes = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.getLabelTypes({
+    first: input.first ?? 50
+  });
+  if (result.error) {
+    throw new Error(`Failed to get label types: ${result.error.message}`);
+  }
+  return {
+    labelTypes: result.data.labelTypes.map((lt) => ({
+      id: lt.id,
+      name: lt.name,
+      isArchived: lt.isArchived
+    }))
+  };
+};
+var formatPlainError = (error) => {
+  let msg = error.message;
+  if (error.type) msg += ` [${error.type}]`;
+  if (error.code) msg += ` (code: ${error.code})`;
+  if (error.fields && error.fields.length > 0) {
+    const fieldDetails = error.fields.map((f) => `  - ${f.field}: ${f.message} (${f.type})`).join("\n");
+    msg += `
+Field errors:
+${fieldDetails}`;
+  }
+  return msg;
+};
+var upsertCustomerByEmail = async (email, fullName, externalId) => {
+  const client2 = getPlainClient();
+  const result = await client2.upsertCustomer({
+    identifier: { emailAddress: email },
+    onCreate: {
+      email: { email, isVerified: true },
+      fullName: fullName ?? email,
+      ...externalId ? { externalId } : {}
+    },
+    onUpdate: {
+      ...fullName ? { fullName: { value: fullName } } : {},
+      ...externalId ? { externalId: { value: externalId } } : {}
+    }
+  });
+  if (result.error) {
+    throw new Error(`Failed to upsert customer: ${formatPlainError(result.error)}`);
+  }
+  return result.data.customer.id;
+};
+var createThread = async (input) => {
+  const client2 = getPlainClient();
+  const identifierCount = [input.customerEmail, input.customerId, input.customerExternalId].filter(Boolean).length;
+  if (identifierCount === 0) {
+    throw new Error("Provide at least one of customerEmail, customerId, or customerExternalId");
+  }
+  if (identifierCount > 1) {
+    throw new Error("Provide only one of customerEmail, customerId, or customerExternalId");
+  }
+  let customerIdentifier;
+  if (input.customerEmail) {
+    const customerId = await upsertCustomerByEmail(
+      input.customerEmail,
+      input.customerFullName,
+      input.customerExternalId
+    );
+    customerIdentifier = { customerId };
+  } else if (input.customerId) {
+    customerIdentifier = { customerId: input.customerId };
+  } else {
+    customerIdentifier = { externalId: input.customerExternalId };
+  }
+  const threadFields = [];
+  const stringFieldMap = [
+    ["app", input.app, ThreadFieldSchemaType.String],
+    ["tenant_id", input.tenantId, ThreadFieldSchemaType.String],
+    ["stage", input.stage, ThreadFieldSchemaType.String],
+    ["reported_from", input.reportedFrom, ThreadFieldSchemaType.String],
+    ["posthog_session", input.posthogSession, ThreadFieldSchemaType.String],
+    ["sentry_session", input.sentrySession, ThreadFieldSchemaType.String],
+    ["notion_ticket", input.notionTicket, ThreadFieldSchemaType.String],
+    ["github_pr", input.githubPr, ThreadFieldSchemaType.String],
+    ["impact_level", input.impactLevel, ThreadFieldSchemaType.Enum]
+  ];
+  for (const [key, value, type] of stringFieldMap) {
+    if (value !== void 0) {
+      threadFields.push({ key, stringValue: value, type });
+    }
+  }
+  if (input.requestFeature !== void 0) {
+    threadFields.push({
+      key: "request_feature",
+      booleanValue: input.requestFeature,
+      type: ThreadFieldSchemaType.Bool
+    });
+  }
+  const result = await client2.createThread({
+    customerIdentifier,
+    title: input.title ?? void 0,
+    description: input.description ?? void 0,
+    components: [{ componentText: { text: input.markdown } }],
+    ...input.priority !== void 0 ? { priority: input.priority } : {},
+    ...input.labelTypeIds ? { labelTypeIds: input.labelTypeIds } : {},
+    ...input.externalId ? { externalId: input.externalId } : {},
+    ...threadFields.length > 0 ? { threadFields } : {}
+  });
+  if (result.error) {
+    throw new Error(`Failed to create thread: ${formatPlainError(result.error)}`);
+  }
+  return {
+    threadId: result.data.id,
+    title: result.data.title ?? void 0,
+    status: result.data.status,
+    priority: result.data.priority
+  };
+};
+
+// src/tools/helpCenter.ts
+var LIST_HELP_CENTERS_QUERY = `
+  query ListHelpCenters($first: Int, $after: String) {
+    helpCenters(first: $first, after: $after) {
+      edges {
+        node {
+          id
+          publicName
+          internalName
+          description
+          type
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var GET_HELP_CENTER_QUERY = `
+  query GetHelpCenter($helpCenterId: ID!) {
+    helpCenter(id: $helpCenterId) {
+      id
+      publicName
+      internalName
+      description
+      type
+      articles(first: 100) {
+        edges {
+          node {
+            id
+            title
+            slug
+            status
+            description
+            articleGroup {
+              id
+              name
+            }
+          }
+        }
+      }
+      articleGroups(first: 50) {
+        edges {
+          node {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+var LIST_HELP_CENTER_ARTICLES_QUERY = `
+  query ListHelpCenterArticles($helpCenterId: ID!, $first: Int) {
+    helpCenter(id: $helpCenterId) {
+      articles(first: $first) {
+        edges {
+          node {
+            id
+            title
+            slug
+            status
+            description
+            contentHtml
+            articleGroup {
+              id
+              name
+            }
+            createdAt { iso8601 }
+            updatedAt { iso8601 }
+          }
+        }
+      }
+    }
+  }
+`;
+var GET_HELP_CENTER_ARTICLE_QUERY = `
+  query GetHelpCenterArticle($helpCenterArticleId: ID!) {
+    helpCenterArticle(id: $helpCenterArticleId) {
+      id
+      title
+      slug
+      status
+      description
+      contentHtml
+      articleGroup {
+        id
+        name
+      }
+      createdAt { iso8601 }
+      updatedAt { iso8601 }
+    }
+  }
+`;
+var GET_HELP_CENTER_ARTICLE_BY_SLUG_QUERY = `
+  query GetHelpCenterArticleBySlug($helpCenterId: ID!, $slug: String!) {
+    helpCenterArticleBySlug(helpCenterId: $helpCenterId, slug: $slug) {
+      id
+      title
+      slug
+      status
+      description
+      contentHtml
+      articleGroup {
+        id
+        name
+      }
+      createdAt { iso8601 }
+      updatedAt { iso8601 }
+    }
+  }
+`;
+var UPSERT_HELP_CENTER_ARTICLE_MUTATION = `
+  mutation UpsertHelpCenterArticle($input: UpsertHelpCenterArticleInput!) {
+    upsertHelpCenterArticle(input: $input) {
+      helpCenterArticle {
+        id
+        title
+        slug
+        status
+        description
+        contentHtml
+        articleGroup {
+          id
+          name
+        }
+        createdAt { iso8601 }
+        updatedAt { iso8601 }
+      }
+      error {
+        message
+        type
+        code
+        fields {
+          field
+          message
+          type
+        }
+      }
+    }
+  }
+`;
+var CREATE_HELP_CENTER_ARTICLE_GROUP_MUTATION = `
+  mutation CreateHelpCenterArticleGroup($input: CreateHelpCenterArticleGroupInput!) {
+    createHelpCenterArticleGroup(input: $input) {
+      helpCenterArticleGroup {
+        id
+        name
+      }
+      error {
+        message
+        type
+        code
+        fields {
+          field
+          message
+          type
+        }
+      }
+    }
+  }
+`;
+var DELETE_HELP_CENTER_ARTICLE_GROUP_MUTATION = `
+  mutation DeleteHelpCenterArticleGroup($input: DeleteHelpCenterArticleGroupInput!) {
+    deleteHelpCenterArticleGroup(input: $input) {
+      error {
+        message
+        type
+        code
+        fields {
+          field
+          message
+          type
+        }
+      }
+    }
+  }
+`;
+var MY_WORKSPACE_QUERY = `
+  query MyWorkspace {
+    myWorkspace {
+      id
+    }
+  }
+`;
+var listHelpCenters = async (_input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: LIST_HELP_CENTERS_QUERY,
+    variables: { first: 25 }
+  });
+  if (result.error) {
+    throw new Error(`Failed to list help centers: ${result.error.message}`);
+  }
+  const data = result.data;
+  return {
+    helpCenters: data.helpCenters.edges.map((edge) => ({
+      id: edge.node.id,
+      publicName: edge.node.publicName,
+      internalName: edge.node.internalName,
+      description: edge.node.description ?? void 0,
+      type: edge.node.type
+    })),
+    pageInfo: data.helpCenters.pageInfo
+  };
+};
+var getHelpCenter = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: GET_HELP_CENTER_QUERY,
+    variables: { helpCenterId: input.helpCenterId }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get help center: ${result.error.message}`);
+  }
+  const data = result.data;
+  const hc = data.helpCenter;
+  if (!hc) {
+    throw new Error(`Help center not found: ${input.helpCenterId}`);
+  }
+  return {
+    id: hc.id,
+    publicName: hc.publicName,
+    internalName: hc.internalName,
+    description: hc.description ?? void 0,
+    type: hc.type,
+    articles: (hc.articles?.edges ?? []).map((edge) => ({
+      id: edge.node.id,
+      title: edge.node.title,
+      slug: edge.node.slug,
+      status: edge.node.status,
+      description: edge.node.description ?? void 0,
+      articleGroup: edge.node.articleGroup ?? void 0
+    })),
+    articleGroups: (hc.articleGroups?.edges ?? []).map((edge) => ({
+      id: edge.node.id,
+      name: edge.node.name
+    }))
+  };
+};
+var listHelpCenterArticles = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: LIST_HELP_CENTER_ARTICLES_QUERY,
+    variables: {
+      helpCenterId: input.helpCenterId,
+      first: input.first ?? 20
+    }
+  });
+  if (result.error) {
+    throw new Error(`Failed to list help center articles: ${result.error.message}`);
+  }
+  const data = result.data;
+  const hc = data.helpCenter;
+  if (!hc) {
+    throw new Error(`Help center not found: ${input.helpCenterId}`);
+  }
+  return {
+    articles: (hc.articles?.edges ?? []).map((edge) => {
+      const node = edge.node;
+      return {
+        id: node.id,
+        title: node.title,
+        slug: node.slug,
+        status: node.status,
+        description: node.description ?? void 0,
+        contentHtml: node.contentHtml,
+        articleGroup: node.articleGroup ?? void 0,
+        createdAt: node.createdAt.iso8601,
+        updatedAt: node.updatedAt.iso8601
+      };
+    })
+  };
+};
+var getHelpCenterArticle = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: GET_HELP_CENTER_ARTICLE_QUERY,
+    variables: { helpCenterArticleId: input.helpCenterArticleId }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get help center article: ${result.error.message}`);
+  }
+  const data = result.data;
+  const article = data.helpCenterArticle;
+  if (!article) {
+    throw new Error(`Help center article not found: ${input.helpCenterArticleId}`);
+  }
+  return {
+    id: article.id,
+    title: article.title,
+    slug: article.slug,
+    status: article.status,
+    description: article.description ?? void 0,
+    contentHtml: article.contentHtml,
+    articleGroup: article.articleGroup ?? void 0,
+    createdAt: article.createdAt.iso8601,
+    updatedAt: article.updatedAt.iso8601
+  };
+};
+var getHelpCenterArticleBySlug = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: GET_HELP_CENTER_ARTICLE_BY_SLUG_QUERY,
+    variables: {
+      helpCenterId: input.helpCenterId,
+      slug: input.slug
+    }
+  });
+  if (result.error) {
+    throw new Error(`Failed to get help center article by slug: ${result.error.message}`);
+  }
+  const data = result.data;
+  const article = data.helpCenterArticleBySlug;
+  if (!article) {
+    throw new Error(`Help center article not found with slug: ${input.slug}`);
+  }
+  return {
+    id: article.id,
+    title: article.title,
+    slug: article.slug,
+    status: article.status,
+    description: article.description ?? void 0,
+    contentHtml: article.contentHtml,
+    articleGroup: article.articleGroup ?? void 0,
+    createdAt: article.createdAt.iso8601,
+    updatedAt: article.updatedAt.iso8601
+  };
+};
+var upsertHelpCenterArticle = async (input) => {
+  const client2 = getPlainClient();
+  const variables = {
+    helpCenterId: input.helpCenterId,
+    title: input.title,
+    contentHtml: input.contentHtml,
+    description: input.description,
+    status: "DRAFT"
+    // Always force DRAFT
+  };
+  if (input.helpCenterArticleId) {
+    variables.helpCenterArticleId = input.helpCenterArticleId;
+  }
+  if (input.slug !== void 0) {
+    variables.slug = input.slug;
+  }
+  if (input.helpCenterArticleGroupId !== void 0 && !input.helpCenterArticleId) {
+    variables.helpCenterArticleGroupId = input.helpCenterArticleGroupId;
+  }
+  const result = await client2.rawRequest({
+    query: UPSERT_HELP_CENTER_ARTICLE_MUTATION,
+    variables: { input: variables }
+  });
+  if (result.error) {
+    throw new Error(`Failed to upsert help center article: ${result.error.message}`);
+  }
+  const data = result.data;
+  const mutationResult = data.upsertHelpCenterArticle;
+  if (mutationResult.error) {
+    const fieldErrors = mutationResult.error.fields?.map((f) => `${f.field}: ${f.message}`).join(", ");
+    throw new Error(
+      `Failed to upsert article: ${mutationResult.error.message}${fieldErrors ? ` (${fieldErrors})` : ""}`
+    );
+  }
+  const article = mutationResult.helpCenterArticle;
+  const workspaceResult = await client2.rawRequest({
+    query: MY_WORKSPACE_QUERY,
+    variables: {}
+  });
+  let link;
+  if (!workspaceResult.error) {
+    const wsData = workspaceResult.data;
+    const workspaceId = wsData.myWorkspace.id;
+    link = `https://app.plain.com/workspace/${workspaceId}/help-center/${input.helpCenterId}/articles/${article.id}/`;
+  }
+  return {
+    id: article.id,
+    title: article.title,
+    slug: article.slug,
+    status: article.status,
+    description: article.description ?? void 0,
+    contentHtml: article.contentHtml,
+    articleGroup: article.articleGroup ?? void 0,
+    createdAt: article.createdAt.iso8601,
+    updatedAt: article.updatedAt.iso8601,
+    ...link ? { link } : {}
+  };
+};
+var createHelpCenterArticleGroup = async (input) => {
+  const client2 = getPlainClient();
+  const variables = {
+    helpCenterId: input.helpCenterId,
+    name: input.name
+  };
+  if (input.parentHelpCenterArticleGroupId !== void 0) {
+    variables.parentHelpCenterArticleGroupId = input.parentHelpCenterArticleGroupId;
+  }
+  const result = await client2.rawRequest({
+    query: CREATE_HELP_CENTER_ARTICLE_GROUP_MUTATION,
+    variables: { input: variables }
+  });
+  if (result.error) {
+    throw new Error(`Failed to create article group: ${result.error.message}`);
+  }
+  const data = result.data;
+  const mutationResult = data.createHelpCenterArticleGroup;
+  if (mutationResult.error) {
+    const fieldErrors = mutationResult.error.fields?.map((f) => `${f.field}: ${f.message}`).join(", ");
+    throw new Error(
+      `Failed to create article group: ${mutationResult.error.message}${fieldErrors ? ` (${fieldErrors})` : ""}`
+    );
+  }
+  return {
+    id: mutationResult.helpCenterArticleGroup.id,
+    name: mutationResult.helpCenterArticleGroup.name
+  };
+};
+var deleteHelpCenterArticleGroup = async (input) => {
+  const client2 = getPlainClient();
+  const result = await client2.rawRequest({
+    query: DELETE_HELP_CENTER_ARTICLE_GROUP_MUTATION,
+    variables: {
+      input: { helpCenterArticleGroupId: input.helpCenterArticleGroupId }
+    }
+  });
+  if (result.error) {
+    throw new Error(`Failed to delete article group: ${result.error.message}`);
+  }
+  const data = result.data;
+  const mutationResult = data.deleteHelpCenterArticleGroup;
+  if (mutationResult.error) {
+    throw new Error(`Failed to delete article group: ${mutationResult.error.message}`);
+  }
+  return { success: true };
+};
+
+// src/index.ts
+if (!process.env.PLAIN_API_KEY) {
+  console.error("Error: PLAIN_API_KEY environment variable is required.");
+  console.error("Set it in your MCP server configuration or shell environment.");
+  process.exit(1);
+}
+var server = new Server(
+  {
+    name: "mcp-plain",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "list_threads",
+      description: "List support threads from Plain with optional filters. Returns thread summaries including id, title, status, priority, customer info, labels, and timestamps.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          statuses: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by thread statuses (e.g., 'TODO', 'DONE', 'SNOOZED')"
+          },
+          priority: {
+            type: "number",
+            minimum: 0,
+            maximum: 3,
+            description: "Filter by priority (0 = urgent, 3 = low)"
+          },
+          labelTypeIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by label type IDs"
+          },
+          customerId: {
+            type: "string",
+            description: "Filter by customer ID"
+          },
+          tenantId: {
+            type: "string",
+            description: "Filter by tenant ID (via thread field)"
+          },
+          first: {
+            type: "number",
+            minimum: 1,
+            maximum: 100,
+            default: 50,
+            description: "Number of threads to return (default 50, max 100)"
+          },
+          after: {
+            type: "string",
+            description: "Cursor for pagination"
+          }
+        }
+      }
+    },
+    {
+      name: "get_thread",
+      description: "Get full details of a specific thread including basic info, customer, labels, custom fields, and timeline entries.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to retrieve"
+          }
+        },
+        required: ["threadId"]
+      }
+    },
+    {
+      name: "get_thread_by_ref",
+      description: "Get full details of a thread by its reference number (e.g., T-510). Returns the same details as get_thread.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ref: {
+            type: "string",
+            description: "Thread reference number (e.g., 'T-510')"
+          }
+        },
+        required: ["ref"]
+      }
+    },
+    {
+      name: "get_thread_fields",
+      description: "Get just the custom field values for a thread. Returns fields like impactLevel, posthogSession, sentrySession, tenant, etc.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to get fields for"
+          }
+        },
+        required: ["threadId"]
+      }
+    },
+    {
+      name: "get_attachment_download_url",
+      description: "Get a temporary download URL for an attachment. Use this to download attachment content when needed. The URL expires after a short time.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          attachmentId: {
+            type: "string",
+            description: "The ID of the attachment to get a download URL for"
+          }
+        },
+        required: ["attachmentId"]
+      }
+    },
+    {
+      name: "get_attachment_content",
+      description: "Fetch the content of an attachment. Returns the content as text for text-based files (text/*, JSON, XML, etc.) or as base64-encoded string for binary files (images, PDFs, etc.). The response includes the encoding type ('text' or 'base64') and MIME type.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          attachmentId: {
+            type: "string",
+            description: "The ID of the attachment to fetch content for"
+          }
+        },
+        required: ["attachmentId"]
+      }
+    },
+    {
+      name: "reply_to_thread",
+      description: "Send a reply to a customer thread. The reply is sent through the original channel (email, Slack, chat). Provide textContent (required) and optionally markdownContent for rich formatting.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to reply to"
+          },
+          textContent: {
+            type: "string",
+            description: "Plain text content of the reply"
+          },
+          markdownContent: {
+            type: "string",
+            description: "Optional markdown-formatted content of the reply"
+          }
+        },
+        required: ["threadId", "textContent"]
+      }
+    },
+    {
+      name: "mark_thread_as_done",
+      description: "Mark a thread as done/resolved. Use this after replying to a thread when the issue has been resolved.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to mark as done"
+          }
+        },
+        required: ["threadId"]
+      }
+    },
+    {
+      name: "upsert_thread_field",
+      description: "Set or update a custom field value on a thread. Use this to write investigation results back to the ticket (e.g., impact_level, app, stage). Field keys use Plain's snake_case format.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to update"
+          },
+          key: {
+            type: "string",
+            description: "Custom field key in snake_case, e.g. impact_level, app, stage, tenant_id, notion_ticket, github_pr, posthog_session, sentry_session, reported_from, request_feature"
+          },
+          value: {
+            type: "string",
+            description: "Field value to set. For boolean fields like request_feature, use 'true' or 'false'"
+          }
+        },
+        required: ["threadId", "key", "value"]
+      }
+    },
+    {
+      name: "add_internal_note",
+      description: "Post an internal note on a thread. Internal notes are visible to the support team only and are NOT sent to the customer. Use this to post investigation summaries, findings, and recommendations.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to add a note to"
+          },
+          markdown: {
+            type: "string",
+            description: "Markdown content for the internal note"
+          }
+        },
+        required: ["threadId", "markdown"]
+      }
+    },
+    {
+      name: "add_labels",
+      description: "Add category labels to a thread. Use get_label_types first to discover available label type IDs for bug, support, feature-request, sales categories.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "The ID of the thread to add labels to"
+          },
+          labelTypeIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of label type IDs to add (get IDs from get_label_types)"
+          }
+        },
+        required: ["threadId", "labelTypeIds"]
+      }
+    },
+    {
+      name: "get_label_types",
+      description: "List available label types in the Plain workspace. Returns label type IDs and names. Call this once to discover the IDs for category labels (bug, support, feature-request, sales) before using add_labels.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          first: {
+            type: "number",
+            minimum: 1,
+            maximum: 100,
+            default: 50,
+            description: "Number of label types to return (default 50)"
+          }
+        }
+      }
+    },
+    {
+      name: "create_thread",
+      description: "Create a new support thread for a customer. Provide exactly one customer identifier (email, ID, or external ID) and markdown content for the initial message. When using customerEmail, the customer is automatically created in Plain if they don't exist. Optionally set title, description, priority, labels, custom fields, and external ID.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          customerEmail: {
+            type: "string",
+            description: "Customer email address. Provide either customerEmail, customerId, or customerExternalId."
+          },
+          customerId: {
+            type: "string",
+            description: "Existing Plain customer ID. Provide either customerEmail, customerId, or customerExternalId."
+          },
+          customerExternalId: {
+            type: "string",
+            description: "Customer external ID. Provide either customerEmail, customerId, or customerExternalId."
+          },
+          customerFullName: {
+            type: "string",
+            description: "Customer full name. Used when upserting a customer by email (ignored when customerId is provided)."
+          },
+          title: {
+            type: "string",
+            description: "Thread title"
+          },
+          description: {
+            type: "string",
+            description: "Thread description / preview text"
+          },
+          markdown: {
+            type: "string",
+            description: "Markdown content for the first timeline entry in the thread"
+          },
+          priority: {
+            type: "number",
+            minimum: 0,
+            maximum: 3,
+            description: "Priority: 0 = urgent, 1 = high, 2 = normal (default), 3 = low"
+          },
+          labelTypeIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Label type IDs to attach. Use get_label_types to discover available IDs."
+          },
+          externalId: {
+            type: "string",
+            description: "Your own unique identifier for this thread"
+          },
+          impactLevel: {
+            type: "string",
+            enum: ["P0", "P1", "P2", "RBS", "RBP", "not-a-bug"],
+            description: "Impact level: P0 (critical), P1, P2, RBS (release blocker staging), RBP (release blocker production), not-a-bug"
+          },
+          app: {
+            type: "string",
+            description: "Affected app identifier (e.g. 'web', 'mobile', 'api')"
+          },
+          tenantId: {
+            type: "string",
+            description: "Tenant ID to associate with the thread"
+          },
+          stage: {
+            type: "string",
+            description: "Environment stage (e.g. 'production', 'staging', 'develop')"
+          },
+          reportedFrom: {
+            type: "string",
+            description: "URL where the issue was reported from"
+          },
+          posthogSession: {
+            type: "string",
+            description: "PostHog session replay URL or session recording ID"
+          },
+          sentrySession: {
+            type: "string",
+            description: "Sentry replay URL or replay ID"
+          },
+          notionTicket: {
+            type: "string",
+            description: "Notion ticket URL or ID"
+          },
+          githubPr: {
+            type: "string",
+            description: "GitHub PR URL"
+          },
+          requestFeature: {
+            type: "boolean",
+            description: "Whether this is a feature request"
+          }
+        },
+        required: ["markdown"]
+      }
+    },
+    // --- Help Center tools ---
+    {
+      name: "list_help_centers",
+      description: "List all help centers in the Plain workspace. Returns help center IDs, names, descriptions, and types. Use this to discover help center IDs before using other help center tools.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "get_help_center",
+      description: "Get a help center by ID with an overview of its article groups and articles (titles, slugs, statuses). Use this to browse the structure of a help center.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterId: {
+            type: "string",
+            description: "The ID of the help center to retrieve"
+          }
+        },
+        required: ["helpCenterId"]
+      }
+    },
+    {
+      name: "list_help_center_articles",
+      description: "List articles in a help center with full content (contentHtml). Use this to read all articles at once for review or analysis.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterId: {
+            type: "string",
+            description: "The ID of the help center to list articles from"
+          },
+          first: {
+            type: "number",
+            minimum: 1,
+            maximum: 100,
+            default: 20,
+            description: "Number of articles to return (default 20, max 100)"
+          }
+        },
+        required: ["helpCenterId"]
+      }
+    },
+    {
+      name: "get_help_center_article",
+      description: "Get a single help center article by ID including its full HTML content, metadata, and group assignment.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterArticleId: {
+            type: "string",
+            description: "The ID of the help center article to retrieve"
+          }
+        },
+        required: ["helpCenterArticleId"]
+      }
+    },
+    {
+      name: "get_help_center_article_by_slug",
+      description: "Get a single help center article by its URL slug. Useful when you know the slug from a URL but not the article ID.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterId: {
+            type: "string",
+            description: "The ID of the help center the article belongs to"
+          },
+          slug: {
+            type: "string",
+            description: "The URL slug of the article"
+          }
+        },
+        required: ["helpCenterId", "slug"]
+      }
+    },
+    {
+      name: "upsert_help_center_article",
+      description: "Create or update a help center article. Articles are always saved as DRAFT status. To update an existing article, provide helpCenterArticleId. Content must be HTML (not markdown). Returns the article data and a link to edit it in the Plain UI.\n\nIMPORTANT: When updating an existing article, you MUST preserve the original HTML formatting exactly. Copy the existing contentHtml verbatim and only modify the specific parts that need changing. Do NOT reformat, re-indent, restructure tags, collapse whitespace, change tag styles, or rewrite any HTML that isn't part of your intended edit. Treat the HTML as a surgical edit, not a rewrite.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterId: {
+            type: "string",
+            description: "The ID of the help center to create/update the article in"
+          },
+          title: {
+            type: "string",
+            description: "Article title"
+          },
+          contentHtml: {
+            type: "string",
+            description: "Article content as HTML (not markdown)"
+          },
+          helpCenterArticleId: {
+            type: "string",
+            description: "Existing article ID for updates. Omit to create a new article."
+          },
+          description: {
+            type: "string",
+            description: "Short description / summary of the article"
+          },
+          slug: {
+            type: "string",
+            description: "URL slug for the article"
+          },
+          helpCenterArticleGroupId: {
+            type: "string",
+            description: "Article group ID to place the article in"
+          }
+        },
+        required: ["helpCenterId", "title", "contentHtml", "description"]
+      }
+    },
+    {
+      name: "create_help_center_article_group",
+      description: "Create a new article group (category/folder) in a help center. Groups organize articles and can be nested.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterId: {
+            type: "string",
+            description: "The ID of the help center to create the group in"
+          },
+          name: {
+            type: "string",
+            description: "Name of the article group"
+          },
+          parentHelpCenterArticleGroupId: {
+            type: "string",
+            description: "Parent group ID for nested groups"
+          }
+        },
+        required: ["helpCenterId", "name"]
+      }
+    },
+    {
+      name: "delete_help_center_article_group",
+      description: "Delete an article group from a help center. The group must be empty (no articles or child groups).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          helpCenterArticleGroupId: {
+            type: "string",
+            description: "The ID of the article group to delete"
+          }
+        },
+        required: ["helpCenterArticleGroupId"]
+      }
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "list_threads": {
+        const input = listThreadsInputSchema.parse(args);
+        const result = await listThreads(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_thread": {
+        const input = getThreadInputSchema.parse(args);
+        const result = await getThread(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_thread_by_ref": {
+        const input = getThreadByRefInputSchema.parse(args);
+        const result = await getThreadByRef(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_thread_fields": {
+        const input = getThreadFieldsInputSchema.parse(args);
+        const result = await getThreadFields(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_attachment_download_url": {
+        const input = getAttachmentDownloadUrlInputSchema.parse(args);
+        const result = await getAttachmentDownloadUrl(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_attachment_content": {
+        const input = getAttachmentContentInputSchema.parse(args);
+        const result = await getAttachmentContent(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "reply_to_thread": {
+        const input = replyToThreadInputSchema.parse(args);
+        const result = await replyToThread(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "mark_thread_as_done": {
+        const input = markThreadAsDoneInputSchema.parse(args);
+        const result = await markThreadAsDone(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "upsert_thread_field": {
+        const input = upsertThreadFieldInputSchema.parse(args);
+        const result = await upsertThreadField(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "add_internal_note": {
+        const input = addInternalNoteInputSchema.parse(args);
+        const result = await addInternalNote(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "add_labels": {
+        const input = addLabelsInputSchema.parse(args);
+        const result = await addLabelsToThread(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_label_types": {
+        const input = getLabelTypesInputSchema.parse(args);
+        const result = await getLabelTypes(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "create_thread": {
+        const input = createThreadInputSchema.parse(args);
+        const result = await createThread(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      // Help Center tools
+      case "list_help_centers": {
+        const input = listHelpCentersInputSchema.parse(args);
+        const result = await listHelpCenters(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_help_center": {
+        const input = getHelpCenterInputSchema.parse(args);
+        const result = await getHelpCenter(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "list_help_center_articles": {
+        const input = listHelpCenterArticlesInputSchema.parse(args);
+        const result = await listHelpCenterArticles(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_help_center_article": {
+        const input = getHelpCenterArticleInputSchema.parse(args);
+        const result = await getHelpCenterArticle(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "get_help_center_article_by_slug": {
+        const input = getHelpCenterArticleBySlugInputSchema.parse(args);
+        const result = await getHelpCenterArticleBySlug(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "upsert_help_center_article": {
+        const input = upsertHelpCenterArticleInputSchema.parse(args);
+        const result = await upsertHelpCenterArticle(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "create_help_center_article_group": {
+        const input = createHelpCenterArticleGroupInputSchema.parse(args);
+        const result = await createHelpCenterArticleGroup(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      case "delete_help_center_article_group": {
+        const input = deleteHelpCenterArticleGroupInputSchema.parse(args);
+        const result = await deleteHelpCenterArticleGroup(input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+  }
+});
+var main = async () => {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Plain MCP server running on stdio");
+};
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});