@burdenoff/mcp-libs 2026.627.1 → 2026.627.3

package/dist/modules/comradecircle/index.cjs

@@ -0,0 +1,1817 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/comradecircle/tools/circles.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/comradecircle/operations.ts
+var PAGE_INFO_FIELDS = `cursor hasMore`;
+var CIRCLE_FIELDS = `
+  id name slug description topic tags status visibility memberCount
+  workspaceId createdAt updatedAt
+  avatar { id }
+`;
+var CHANNEL_FIELDS = `
+  id circleId name slug description type visibility position isArchived
+  workspaceId createdAt updatedAt
+`;
+var MEMBERSHIP_FIELDS = `
+  id circleId memberId role status joinedAt workspaceId createdAt updatedAt
+  member { id }
+`;
+var PROFILE_FIELDS = `
+  id memberId displayName headline bio interests skills presence discoverable
+  workspaceId createdAt updatedAt
+  avatar { id }
+  member { id }
+`;
+var COMMENT_FIELDS = `
+  id postId parentId authorId body isHidden workspaceId createdAt updatedAt
+  author { id }
+`;
+var REACTION_FIELDS = `
+  id postId memberId type createdAt workspaceId
+  member { id }
+`;
+var POST_FIELDS = `
+  id channelId authorId body status tags attachmentFileIds isPinned
+  commentCount reactionCount workspaceId createdAt updatedAt
+  author { id }
+`;
+var RSVP_FIELDS = `
+  id eventId memberId status note workspaceId createdAt updatedAt
+  member { id }
+`;
+var EVENT_FIELDS = `
+  id circleId hostId title description mode status location joinUrl capacity
+  rsvpCount startsAt endsAt tags workspaceId createdAt updatedAt
+  host { id }
+`;
+var POLL_OPTION_FIELDS = `
+  id pollId label position voteCount workspaceId createdAt
+`;
+var POLL_FIELDS = `
+  id circleId question status isAnonymous allowMultiple closesAt
+  workspaceId createdAt updatedAt
+  options { ${POLL_OPTION_FIELDS} }
+`;
+var FEED_FOLLOW_FIELDS = `
+  id followerId targetId targetType muted workspaceId createdAt updatedAt
+`;
+var GET_CIRCLE = `
+  query ComradecircleGetCircle($id: ID!) {
+    comCircle(id: $id) {
+      ${CIRCLE_FIELDS}
+      channels { ${CHANNEL_FIELDS} }
+      memberships { ${MEMBERSHIP_FIELDS} }
+    }
+  }
+`;
+var LIST_CIRCLES = `
+  query ComradecircleListCircles(
+    $pagination: PaginationInput
+    $status: ComCircleStatus
+    $visibility: ComCircleVisibility
+  ) {
+    comListCircles(pagination: $pagination, status: $status, visibility: $visibility) {
+      items { ${CIRCLE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_CIRCLE = `
+  mutation ComradecircleCreateCircle($input: ComCreateCircleInput!) {
+    comCreateCircle(input: $input) {
+      ${CIRCLE_FIELDS}
+    }
+  }
+`;
+var UPDATE_CIRCLE = `
+  mutation ComradecircleUpdateCircle($id: ID!, $input: ComUpdateCircleInput!) {
+    comUpdateCircle(id: $id, input: $input) {
+      ${CIRCLE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_CIRCLE = `
+  mutation ComradecircleArchiveCircle($id: ID!) {
+    comArchiveCircle(id: $id)
+  }
+`;
+var JOIN_CIRCLE = `
+  mutation ComradecircleJoinCircle($circleId: ID!) {
+    comJoinCircle(circleId: $circleId) {
+      ${MEMBERSHIP_FIELDS}
+    }
+  }
+`;
+var LEAVE_CIRCLE = `
+  mutation ComradecircleLeaveCircle($circleId: ID!) {
+    comLeaveCircle(circleId: $circleId)
+  }
+`;
+var LIST_CHANNELS = `
+  query ComradecircleListChannels($circleId: ID!) {
+    comListChannels(circleId: $circleId) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var CREATE_CHANNEL = `
+  mutation ComradecircleCreateChannel($input: ComCreateChannelInput!) {
+    comCreateChannel(input: $input) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var UPDATE_CHANNEL = `
+  mutation ComradecircleUpdateChannel($id: ID!, $input: ComUpdateChannelInput!) {
+    comUpdateChannel(id: $id, input: $input) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var LIST_MEMBERSHIPS = `
+  query ComradecircleListMemberships(
+    $circleId: ID
+    $pagination: PaginationInput
+    $status: ComMembershipStatus
+  ) {
+    comListMemberships(circleId: $circleId, pagination: $pagination, status: $status) {
+      items { ${MEMBERSHIP_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var SET_MEMBER_ROLE = `
+  mutation ComradecircleSetMemberRole($membershipId: ID!, $role: ComMemberRole!) {
+    comSetMemberRole(membershipId: $membershipId, role: $role) {
+      ${MEMBERSHIP_FIELDS}
+    }
+  }
+`;
+var GET_PROFILE = `
+  query ComradecircleGetProfile($memberId: ID!) {
+    comProfile(memberId: $memberId) {
+      ${PROFILE_FIELDS}
+    }
+  }
+`;
+var LIST_PROFILES = `
+  query ComradecircleListProfiles($discoverable: Boolean, $pagination: PaginationInput) {
+    comListProfiles(discoverable: $discoverable, pagination: $pagination) {
+      items { ${PROFILE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var UPSERT_PROFILE = `
+  mutation ComradecircleUpsertProfile($input: ComUpsertProfileInput!) {
+    comUpsertProfile(input: $input) {
+      ${PROFILE_FIELDS}
+    }
+  }
+`;
+var GET_POST = `
+  query ComradecircleGetPost($id: ID!) {
+    comPost(id: $id) {
+      ${POST_FIELDS}
+      comments { ${COMMENT_FIELDS} }
+      reactions { ${REACTION_FIELDS} }
+    }
+  }
+`;
+var LIST_POSTS = `
+  query ComradecircleListPosts(
+    $channelId: ID
+    $pagination: PaginationInput
+    $status: ComPostStatus
+  ) {
+    comListPosts(channelId: $channelId, pagination: $pagination, status: $status) {
+      items { ${POST_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_POST = `
+  mutation ComradecircleCreatePost($input: ComCreatePostInput!) {
+    comCreatePost(input: $input) {
+      ${POST_FIELDS}
+    }
+  }
+`;
+var UPDATE_POST = `
+  mutation ComradecircleUpdatePost($id: ID!, $input: ComUpdatePostInput!) {
+    comUpdatePost(id: $id, input: $input) {
+      ${POST_FIELDS}
+    }
+  }
+`;
+var REMOVE_POST = `
+  mutation ComradecircleRemovePost($id: ID!) {
+    comRemovePost(id: $id)
+  }
+`;
+var REACT_TO_POST = `
+  mutation ComradecircleReactToPost($postId: ID!, $type: ComReactionType!) {
+    comReactToPost(postId: $postId, type: $type) {
+      ${POST_FIELDS}
+      reactions { ${REACTION_FIELDS} }
+    }
+  }
+`;
+var LIST_COMMENTS = `
+  query ComradecircleListComments($postId: ID!) {
+    comListComments(postId: $postId) {
+      ${COMMENT_FIELDS}
+    }
+  }
+`;
+var ADD_COMMENT = `
+  mutation ComradecircleAddComment($input: ComCreateCommentInput!) {
+    comAddComment(input: $input) {
+      ${COMMENT_FIELDS}
+    }
+  }
+`;
+var MY_FEED = `
+  query ComradecircleMyFeed($pagination: PaginationInput) {
+    comMyFeed(pagination: $pagination) {
+      items { ${POST_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var MY_FOLLOWS = `
+  query ComradecircleMyFollows($targetType: ComFollowTargetType) {
+    comMyFollows(targetType: $targetType) {
+      ${FEED_FOLLOW_FIELDS}
+    }
+  }
+`;
+var FOLLOW = `
+  mutation ComradecircleFollow($input: ComFollowInput!) {
+    comFollow(input: $input) {
+      ${FEED_FOLLOW_FIELDS}
+    }
+  }
+`;
+var UNFOLLOW = `
+  mutation ComradecircleUnfollow($input: ComFollowInput!) {
+    comUnfollow(input: $input)
+  }
+`;
+var MUTE_FOLLOW = `
+  mutation ComradecircleMuteFollow($id: ID!, $muted: Boolean!) {
+    comMuteFollow(id: $id, muted: $muted) {
+      ${FEED_FOLLOW_FIELDS}
+    }
+  }
+`;
+var GET_EVENT = `
+  query ComradecircleGetEvent($id: ID!) {
+    comEvent(id: $id) {
+      ${EVENT_FIELDS}
+      rsvps { ${RSVP_FIELDS} }
+    }
+  }
+`;
+var LIST_EVENTS = `
+  query ComradecircleListEvents(
+    $circleId: ID
+    $pagination: PaginationInput
+    $status: ComEventStatus
+  ) {
+    comListEvents(circleId: $circleId, pagination: $pagination, status: $status) {
+      items { ${EVENT_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_EVENT = `
+  mutation ComradecircleCreateEvent($input: ComCreateEventInput!) {
+    comCreateEvent(input: $input) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var UPDATE_EVENT = `
+  mutation ComradecircleUpdateEvent($id: ID!, $input: ComUpdateEventInput!) {
+    comUpdateEvent(id: $id, input: $input) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var TRANSITION_EVENT = `
+  mutation ComradecircleTransitionEvent($id: ID!, $status: ComEventStatus!) {
+    comTransitionEvent(id: $id, status: $status) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var RSVP_EVENT = `
+  mutation ComradecircleRsvpEvent($eventId: ID!, $status: ComRsvpStatus!, $note: String) {
+    comRsvpEvent(eventId: $eventId, status: $status, note: $note) {
+      ${RSVP_FIELDS}
+    }
+  }
+`;
+var GET_POLL = `
+  query ComradecircleGetPoll($id: ID!) {
+    comPoll(id: $id) {
+      ${POLL_FIELDS}
+    }
+  }
+`;
+var LIST_POLLS = `
+  query ComradecircleListPolls($circleId: ID!, $status: ComPollStatus) {
+    comListPolls(circleId: $circleId, status: $status) {
+      ${POLL_FIELDS}
+    }
+  }
+`;
+var CREATE_POLL = `
+  mutation ComradecircleCreatePoll($input: ComCreatePollInput!) {
+    comCreatePoll(input: $input) {
+      ${POLL_FIELDS}
+    }
+  }
+`;
+var CLOSE_POLL = `
+  mutation ComradecircleClosePoll($id: ID!) {
+    comClosePoll(id: $id) {
+      ${POLL_FIELDS}
+    }
+  }
+`;
+var VOTE_POLL = `
+  mutation ComradecircleVotePoll($pollId: ID!, $optionId: ID!) {
+    comVotePoll(pollId: $pollId, optionId: $optionId) {
+      ${POLL_OPTION_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query ComradecircleHealth {
+    comHealth
+  }
+`;
+var ChannelTypeEnum = zod.z.enum(["ANNOUNCEMENT", "FORUM", "TEXT", "VOICE"]).describe("Kind of channel within a circle");
+var ChannelVisibilityEnum = zod.z.enum(["CIRCLE", "PRIVATE"]).describe("Who can see a channel: CIRCLE-wide or PRIVATE");
+var CircleStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "SUSPENDED"]).describe("Lifecycle/moderation status of a circle");
+var CircleVisibilityEnum = zod.z.enum(["PUBLIC", "PRIVATE", "SECRET"]).describe("Discoverability of a circle: PUBLIC, PRIVATE (join-by-request), or SECRET");
+var EventModeEnum = zod.z.enum(["ONLINE", "IN_PERSON", "HYBRID"]).describe("Delivery mode of an event");
+var EventStatusEnum = zod.z.enum(["SCHEDULED", "LIVE", "COMPLETED", "CANCELLED"]).describe("Lifecycle status of an event");
+var FollowTargetTypeEnum = zod.z.enum(["CIRCLE", "CHANNEL", "MEMBER"]).describe("What a feed-follow targets");
+var MemberRoleEnum = zod.z.enum(["OWNER", "ADMIN", "MODERATOR", "MEMBER"]).describe("Role of a member within a circle");
+var MembershipStatusEnum = zod.z.enum(["ACTIVE", "PENDING", "LEFT", "BANNED"]).describe("Status of a circle membership");
+var PollStatusEnum = zod.z.enum(["OPEN", "CLOSED"]).describe("Lifecycle status of a poll");
+var PostStatusEnum = zod.z.enum(["DRAFT", "PUBLISHED", "HIDDEN", "REMOVED"]).describe("Publication status of a post");
+var PresenceEnum = zod.z.enum(["ONLINE", "AWAY", "BUSY", "OFFLINE"]).describe("Presence indicator of a member profile");
+var ReactionTypeEnum = zod.z.enum(["LIKE", "LOVE", "CELEBRATE", "INSIGHTFUL", "SUPPORT", "LAUGH"]).describe("Typed reaction on a post");
+var RsvpStatusEnum = zod.z.enum(["GOING", "INTERESTED", "NOT_GOING", "WAITLISTED"]).describe("RSVP response to an event");
+function buildPagination(limit, offset, cursor) {
+  if (limit === void 0 && offset === void 0 && cursor === void 0) return void 0;
+  const pagination = {};
+  if (limit !== void 0) pagination.limit = limit;
+  if (offset !== void 0) pagination.offset = offset;
+  if (cursor !== void 0) pagination.cursor = cursor;
+  return pagination;
+}
+
+// src/modules/comradecircle/tools/circles.ts
+function registerCircleTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "circles_get")),
+    {
+      title: "Get Circle",
+      description: "Fetch a single Comradecircle circle (community) by ID, including its channels and memberships.",
+      inputSchema: { id: zod.z.string().describe("Circle ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CIRCLE, { id });
+        if (!data.comCircle) return errorResult(`Circle ${id} not found`);
+        return jsonResult(data.comCircle);
+      } catch (error) {
+        ctx.logger.error("comradecircle circles_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "circles_list")),
+    {
+      title: "List Circles",
+      description: "List circles in the bound workspace with optional status/visibility filters and pagination.",
+      inputSchema: {
+        status: CircleStatusEnum.optional().describe("Filter by lifecycle status"),
+        visibility: CircleVisibilityEnum.optional().describe("Filter by visibility"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ status, visibility, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CIRCLES, {
+          status,
+          visibility,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.comListCircles);
+      } catch (error) {
+        ctx.logger.error("comradecircle circles_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list circles: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "circles_create")),
+    {
+      title: "Create Circle",
+      description: "Create a new circle (community). `slug` must be unique within the workspace. The caller is enrolled as the OWNER.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Circle display name"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        description: zod.z.string().optional().describe("Circle description"),
+        topic: zod.z.string().optional().describe("Short topic/tagline"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form topical tags"),
+        visibility: CircleVisibilityEnum.optional().describe("Visibility (default PUBLIC)"),
+        avatarFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the avatar")
+      }
+    },
+    async ({ name, slug, description, topic, tags, visibility, avatarFileId }) => {
+      try {
+        const input = { name, slug };
+        if (description !== void 0) input.description = description;
+        if (topic !== void 0) input.topic = topic;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (avatarFileId !== void 0) input.avatarFileId = avatarFileId;
+        const data = await ctx.gql.workspace.request(CREATE_CIRCLE, { input });
+        return jsonResult(data.comCreateCircle);
+      } catch (error) {
+        ctx.logger.error("comradecircle circles_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "circles_update")),
+    {
+      title: "Update Circle",
+      description: "Update a circle. At least one mutable field must be provided. Use the archive tool to soft-delete.",
+      inputSchema: {
+        id: zod.z.string().describe("Circle ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        topic: zod.z.string().optional().describe("Updated topic/tagline"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated topical tags"),
+        visibility: CircleVisibilityEnum.optional().describe("Updated visibility"),
+        avatarFileId: zod.z.string().optional().describe("Updated avatar File ID")
+      }
+    },
+    async ({ id, name, description, topic, tags, visibility, avatarFileId }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (topic !== void 0) input.topic = topic;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (avatarFileId !== void 0) input.avatarFileId = avatarFileId;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/topic/tags/visibility/avatarFileId"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_CIRCLE, { id, input });
+        return jsonResult(data.comUpdateCircle);
+      } catch (error) {
+        ctx.logger.error("comradecircle circles_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "circles_archive")),
+    {
+      title: "Archive Circle",
+      description: "Archive (soft-delete) a circle. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Circle ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_CIRCLE,
+          { id }
+        );
+        return jsonResult({ archived: data.comArchiveCircle });
+      } catch (error) {
+        ctx.logger.error("comradecircle circles_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerChannelTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_list")),
+    {
+      title: "List Channels",
+      description: "List the channels belonging to a circle, ordered by position.",
+      inputSchema: { circleId: zod.z.string().describe("Circle ID") }
+    },
+    async ({ circleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CHANNELS, { circleId });
+        return jsonResult(data.comListChannels);
+      } catch (error) {
+        ctx.logger.error("comradecircle channels_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list channels: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_create")),
+    {
+      title: "Create Channel",
+      description: "Create a channel within a circle. `slug` must be unique within the circle. `type` defaults to TEXT; `visibility` defaults to CIRCLE.",
+      inputSchema: {
+        circleId: zod.z.string().min(1).describe("Parent circle ID"),
+        name: zod.z.string().min(1).describe("Channel display name"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the circle"),
+        description: zod.z.string().optional().describe("Channel description"),
+        type: ChannelTypeEnum.optional().describe("Channel type (default TEXT)"),
+        visibility: ChannelVisibilityEnum.optional().describe(
+          "Channel visibility (default CIRCLE)"
+        ),
+        position: zod.z.number().int().optional().describe("Sort position within the circle")
+      }
+    },
+    async ({ circleId, name, slug, description, type, visibility, position }) => {
+      try {
+        const input = { circleId, name, slug };
+        if (description !== void 0) input.description = description;
+        if (type !== void 0) input.type = type;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (position !== void 0) input.position = position;
+        const data = await ctx.gql.workspace.request(CREATE_CHANNEL, { input });
+        return jsonResult(data.comCreateChannel);
+      } catch (error) {
+        ctx.logger.error("comradecircle channels_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create channel: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_update")),
+    {
+      title: "Update Channel",
+      description: "Update a channel. At least one mutable field must be provided. Use `isArchived` to archive/unarchive.",
+      inputSchema: {
+        id: zod.z.string().describe("Channel ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        type: ChannelTypeEnum.optional().describe("Updated channel type"),
+        visibility: ChannelVisibilityEnum.optional().describe("Updated visibility"),
+        position: zod.z.number().int().optional().describe("Updated sort position"),
+        isArchived: zod.z.boolean().optional().describe("Archive (true) or unarchive (false)")
+      }
+    },
+    async ({ id, name, description, type, visibility, position, isArchived }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (type !== void 0) input.type = type;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (position !== void 0) input.position = position;
+        if (isArchived !== void 0) input.isArchived = isArchived;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/type/visibility/position/isArchived"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_CHANNEL, { id, input });
+        return jsonResult(data.comUpdateChannel);
+      } catch (error) {
+        ctx.logger.error("comradecircle channels_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update channel: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMembershipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_join")),
+    {
+      title: "Join Circle",
+      description: "Join a circle as the calling member (idempotent \u2014 re-activates a LEFT membership). Returns the membership.",
+      inputSchema: { circleId: zod.z.string().describe("Circle ID to join") }
+    },
+    async ({ circleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(JOIN_CIRCLE, { circleId });
+        return jsonResult(data.comJoinCircle);
+      } catch (error) {
+        ctx.logger.error("comradecircle memberships_join failed", { error: String(error) });
+        return errorResult(
+          `Failed to join circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_leave")),
+    {
+      title: "Leave Circle",
+      description: "Leave a circle as the calling member. Returns true on success.",
+      inputSchema: { circleId: zod.z.string().describe("Circle ID to leave") }
+    },
+    async ({ circleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LEAVE_CIRCLE,
+          {
+            circleId
+          }
+        );
+        return jsonResult({ left: data.comLeaveCircle });
+      } catch (error) {
+        ctx.logger.error("comradecircle memberships_leave failed", { error: String(error) });
+        return errorResult(
+          `Failed to leave circle: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_list")),
+    {
+      title: "List Memberships",
+      description: "List circle memberships, optionally filtered by circle and/or status, with pagination.",
+      inputSchema: {
+        circleId: zod.z.string().optional().describe("Filter by circle ID"),
+        status: MembershipStatusEnum.optional().describe("Filter by membership status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ circleId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEMBERSHIPS, {
+          circleId,
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.comListMemberships);
+      } catch (error) {
+        ctx.logger.error("comradecircle memberships_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list memberships: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_set_role")),
+    {
+      title: "Set Member Role",
+      description: "Change a member\u2019s role within a circle (OWNER/ADMIN/MODERATOR/MEMBER). Returns the updated membership.",
+      inputSchema: {
+        membershipId: zod.z.string().describe("Membership ID"),
+        role: MemberRoleEnum.describe("New role to assign")
+      }
+    },
+    async ({ membershipId, role }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_MEMBER_ROLE, { membershipId, role });
+        return jsonResult(data.comSetMemberRole);
+      } catch (error) {
+        ctx.logger.error("comradecircle memberships_set_role failed", { error: String(error) });
+        return errorResult(
+          `Failed to set member role: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProfileTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_get")),
+    {
+      title: "Get Member Profile",
+      description: "Fetch a member\u2019s Comradecircle profile by their member (user) ID.",
+      inputSchema: { memberId: zod.z.string().describe("Member (user) ID") }
+    },
+    async ({ memberId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROFILE, { memberId });
+        if (!data.comProfile) return errorResult(`Profile for member ${memberId} not found`);
+        return jsonResult(data.comProfile);
+      } catch (error) {
+        ctx.logger.error("comradecircle profiles_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_list")),
+    {
+      title: "List Member Profiles",
+      description: "List member profiles in the bound workspace, optionally restricted to discoverable profiles, with pagination.",
+      inputSchema: {
+        discoverable: zod.z.boolean().optional().describe("Only profiles that opted into discovery"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ discoverable, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROFILES, {
+          discoverable,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.comListProfiles);
+      } catch (error) {
+        ctx.logger.error("comradecircle profiles_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list profiles: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_upsert")),
+    {
+      title: "Upsert My Profile",
+      description: "Create or update the calling member\u2019s profile (one per member per workspace). `displayName` is required.",
+      inputSchema: {
+        displayName: zod.z.string().min(1).describe("Display name"),
+        headline: zod.z.string().optional().describe("Short headline/title"),
+        bio: zod.z.string().optional().describe("Profile bio"),
+        interests: zod.z.array(zod.z.string()).optional().describe("Interest tags"),
+        skills: zod.z.array(zod.z.string()).optional().describe("Skill tags"),
+        presence: PresenceEnum.optional().describe("Presence indicator"),
+        discoverable: zod.z.boolean().optional().describe("Opt into member discovery"),
+        avatarFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the avatar")
+      }
+    },
+    async ({
+      displayName,
+      headline,
+      bio,
+      interests,
+      skills,
+      presence,
+      discoverable,
+      avatarFileId
+    }) => {
+      try {
+        const input = { displayName };
+        if (headline !== void 0) input.headline = headline;
+        if (bio !== void 0) input.bio = bio;
+        if (interests !== void 0) input.interests = interests;
+        if (skills !== void 0) input.skills = skills;
+        if (presence !== void 0) input.presence = presence;
+        if (discoverable !== void 0) input.discoverable = discoverable;
+        if (avatarFileId !== void 0) input.avatarFileId = avatarFileId;
+        const data = await ctx.gql.workspace.request(UPSERT_PROFILE, { input });
+        return jsonResult(data.comUpsertProfile);
+      } catch (error) {
+        ctx.logger.error("comradecircle profiles_upsert failed", { error: String(error) });
+        return errorResult(
+          `Failed to upsert profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPostTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_get")),
+    {
+      title: "Get Post",
+      description: "Fetch a single post by ID, including its comments and reactions.",
+      inputSchema: { id: zod.z.string().describe("Post ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_POST, { id });
+        if (!data.comPost) return errorResult(`Post ${id} not found`);
+        return jsonResult(data.comPost);
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get post: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_list")),
+    {
+      title: "List Posts",
+      description: "List posts, optionally filtered by channel and/or status, newest first, with pagination.",
+      inputSchema: {
+        channelId: zod.z.string().optional().describe("Filter by channel ID"),
+        status: PostStatusEnum.optional().describe("Filter by post status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ channelId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_POSTS, {
+          channelId,
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.comListPosts);
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list posts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_create")),
+    {
+      title: "Create Post",
+      description: "Create a post in a channel. `status` defaults to PUBLISHED. Attach files by their wspace-files-svc File IDs.",
+      inputSchema: {
+        channelId: zod.z.string().min(1).describe("Target channel ID"),
+        body: zod.z.string().min(1).describe("Post body"),
+        status: PostStatusEnum.optional().describe("Initial status (default PUBLISHED)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Topical tags"),
+        attachmentFileIds: zod.z.array(zod.z.string()).optional().describe("wspace-files-svc File IDs to attach")
+      }
+    },
+    async ({ channelId, body, status, tags, attachmentFileIds }) => {
+      try {
+        const input = { channelId, body };
+        if (status !== void 0) input.status = status;
+        if (tags !== void 0) input.tags = tags;
+        if (attachmentFileIds !== void 0) input.attachmentFileIds = attachmentFileIds;
+        const data = await ctx.gql.workspace.request(CREATE_POST, { input });
+        return jsonResult(data.comCreatePost);
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create post: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_update")),
+    {
+      title: "Update Post",
+      description: "Update a post. At least one mutable field must be provided. Use `isPinned` to pin/unpin and `status` to hide/publish.",
+      inputSchema: {
+        id: zod.z.string().describe("Post ID"),
+        body: zod.z.string().optional().describe("Updated body"),
+        status: PostStatusEnum.optional().describe("Updated status"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        isPinned: zod.z.boolean().optional().describe("Pin (true) or unpin (false)")
+      }
+    },
+    async ({ id, body, status, tags, isPinned }) => {
+      try {
+        const input = {};
+        if (body !== void 0) input.body = body;
+        if (status !== void 0) input.status = status;
+        if (tags !== void 0) input.tags = tags;
+        if (isPinned !== void 0) input.isPinned = isPinned;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of body/status/tags/isPinned"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_POST, { id, input });
+        return jsonResult(data.comUpdatePost);
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update post: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_remove")),
+    {
+      title: "Remove Post",
+      description: "Remove (soft-delete) a post. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Post ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REMOVE_POST, {
+          id
+        });
+        return jsonResult({ removed: data.comRemovePost });
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove post: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "posts_react")),
+    {
+      title: "React to Post",
+      description: "Toggle a typed reaction on a post for the calling member (idempotent add/remove). Returns the updated post.",
+      inputSchema: {
+        postId: zod.z.string().describe("Post ID"),
+        type: ReactionTypeEnum.describe("Reaction type to toggle")
+      }
+    },
+    async ({ postId, type }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REACT_TO_POST, { postId, type });
+        return jsonResult(data.comReactToPost);
+      } catch (error) {
+        ctx.logger.error("comradecircle posts_react failed", { error: String(error) });
+        return errorResult(
+          `Failed to react to post: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCommentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "comments_list")),
+    {
+      title: "List Comments",
+      description: "List the comments on a post (threaded via each comment\u2019s parentId).",
+      inputSchema: { postId: zod.z.string().describe("Post ID") }
+    },
+    async ({ postId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COMMENTS, { postId });
+        return jsonResult(data.comListComments);
+      } catch (error) {
+        ctx.logger.error("comradecircle comments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list comments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "comments_add")),
+    {
+      title: "Add Comment",
+      description: "Add a comment to a post as the calling member. Pass `parentId` to reply to an existing comment.",
+      inputSchema: {
+        postId: zod.z.string().min(1).describe("Post being commented on"),
+        body: zod.z.string().min(1).describe("Comment body"),
+        parentId: zod.z.string().optional().describe("Parent comment ID (for replies)")
+      }
+    },
+    async ({ postId, body, parentId }) => {
+      try {
+        const input = { postId, body };
+        if (parentId !== void 0) input.parentId = parentId;
+        const data = await ctx.gql.workspace.request(ADD_COMMENT, { input });
+        return jsonResult(data.comAddComment);
+      } catch (error) {
+        ctx.logger.error("comradecircle comments_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add comment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerFeedTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feed_my_feed")),
+    {
+      title: "My Home Feed",
+      description: "The calling member\u2019s unified home feed \u2014 published posts from every channel, member, and circle they follow, newest first.",
+      inputSchema: {
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_FEED, { pagination: buildPagination(limit, offset, cursor) });
+        return jsonResult(data.comMyFeed);
+      } catch (error) {
+        ctx.logger.error("comradecircle feed_my_feed failed", { error: String(error) });
+        return errorResult(
+          `Failed to load home feed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feed_my_follows")),
+    {
+      title: "List My Follows",
+      description: "List the calling member\u2019s feed-follows, optionally filtered by target type (CIRCLE/CHANNEL/MEMBER).",
+      inputSchema: {
+        targetType: FollowTargetTypeEnum.optional().describe("Filter by follow target type")
+      }
+    },
+    async ({ targetType }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_FOLLOWS, { targetType });
+        return jsonResult(data.comMyFollows);
+      } catch (error) {
+        ctx.logger.error("comradecircle feed_my_follows failed", { error: String(error) });
+        return errorResult(
+          `Failed to list follows: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feed_follow")),
+    {
+      title: "Follow Target",
+      description: "Follow a circle, channel, or member so their posts appear in the calling member\u2019s home feed.",
+      inputSchema: {
+        targetId: zod.z.string().min(1).describe("ID of the circle/channel/member to follow"),
+        targetType: FollowTargetTypeEnum.describe("What is being followed")
+      }
+    },
+    async ({ targetId, targetType }) => {
+      try {
+        const data = await ctx.gql.workspace.request(FOLLOW, { input: { targetId, targetType } });
+        return jsonResult(data.comFollow);
+      } catch (error) {
+        ctx.logger.error("comradecircle feed_follow failed", { error: String(error) });
+        return errorResult(
+          `Failed to follow target: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feed_unfollow")),
+    {
+      title: "Unfollow Target",
+      description: "Stop following a circle, channel, or member. Returns true on success.",
+      inputSchema: {
+        targetId: zod.z.string().min(1).describe("ID of the circle/channel/member to unfollow"),
+        targetType: FollowTargetTypeEnum.describe("What is being unfollowed")
+      }
+    },
+    async ({ targetId, targetType }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNFOLLOW, {
+          input: { targetId, targetType }
+        });
+        return jsonResult({ unfollowed: data.comUnfollow });
+      } catch (error) {
+        ctx.logger.error("comradecircle feed_unfollow failed", { error: String(error) });
+        return errorResult(
+          `Failed to unfollow target: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feed_mute_follow")),
+    {
+      title: "Mute Follow",
+      description: "Mute or unmute a feed-follow \u2014 muted targets stay followed but are suppressed from the home feed.",
+      inputSchema: {
+        id: zod.z.string().describe("Feed-follow ID"),
+        muted: zod.z.boolean().describe("Mute (true) or unmute (false)")
+      }
+    },
+    async ({ id, muted }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MUTE_FOLLOW, { id, muted });
+        return jsonResult(data.comMuteFollow);
+      } catch (error) {
+        ctx.logger.error("comradecircle feed_mute_follow failed", { error: String(error) });
+        return errorResult(
+          `Failed to mute follow: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEventTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_get")),
+    {
+      title: "Get Event",
+      description: "Fetch a single event by ID, including its RSVPs.",
+      inputSchema: { id: zod.z.string().describe("Event ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_EVENT, { id });
+        if (!data.comEvent) return errorResult(`Event ${id} not found`);
+        return jsonResult(data.comEvent);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_list")),
+    {
+      title: "List Events",
+      description: "List events, optionally filtered by circle and/or status, with pagination.",
+      inputSchema: {
+        circleId: zod.z.string().optional().describe("Filter by circle ID"),
+        status: EventStatusEnum.optional().describe("Filter by event status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ circleId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EVENTS, {
+          circleId,
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.comListEvents);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_create")),
+    {
+      title: "Create Event",
+      description: "Schedule an event in a circle. `startsAt` is required (ISO-8601 DateTime); `mode` defaults to ONLINE.",
+      inputSchema: {
+        circleId: zod.z.string().min(1).describe("Host circle ID"),
+        title: zod.z.string().min(1).describe("Event title"),
+        startsAt: zod.z.string().min(1).describe("Start time (ISO-8601 DateTime)"),
+        description: zod.z.string().optional().describe("Event description"),
+        mode: EventModeEnum.optional().describe("Delivery mode (default ONLINE)"),
+        location: zod.z.string().optional().describe("Physical location (for IN_PERSON/HYBRID)"),
+        joinUrl: zod.z.string().optional().describe("Join URL (for ONLINE/HYBRID)"),
+        capacity: zod.z.number().int().optional().describe("Maximum attendees"),
+        endsAt: zod.z.string().optional().describe("End time (ISO-8601 DateTime)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Topical tags")
+      }
+    },
+    async ({
+      circleId,
+      title,
+      startsAt,
+      description,
+      mode,
+      location,
+      joinUrl,
+      capacity,
+      endsAt,
+      tags
+    }) => {
+      try {
+        const input = { circleId, title, startsAt };
+        if (description !== void 0) input.description = description;
+        if (mode !== void 0) input.mode = mode;
+        if (location !== void 0) input.location = location;
+        if (joinUrl !== void 0) input.joinUrl = joinUrl;
+        if (capacity !== void 0) input.capacity = capacity;
+        if (endsAt !== void 0) input.endsAt = endsAt;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_EVENT, { input });
+        return jsonResult(data.comCreateEvent);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_update")),
+    {
+      title: "Update Event",
+      description: "Update an event\u2019s details. At least one mutable field must be provided. Use the transition tool to change status.",
+      inputSchema: {
+        id: zod.z.string().describe("Event ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        description: zod.z.string().optional().describe("Updated description"),
+        mode: EventModeEnum.optional().describe("Updated delivery mode"),
+        location: zod.z.string().optional().describe("Updated location"),
+        joinUrl: zod.z.string().optional().describe("Updated join URL"),
+        capacity: zod.z.number().int().optional().describe("Updated capacity"),
+        startsAt: zod.z.string().optional().describe("Updated start time (ISO-8601 DateTime)"),
+        endsAt: zod.z.string().optional().describe("Updated end time (ISO-8601 DateTime)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      description,
+      mode,
+      location,
+      joinUrl,
+      capacity,
+      startsAt,
+      endsAt,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (mode !== void 0) input.mode = mode;
+        if (location !== void 0) input.location = location;
+        if (joinUrl !== void 0) input.joinUrl = joinUrl;
+        if (capacity !== void 0) input.capacity = capacity;
+        if (startsAt !== void 0) input.startsAt = startsAt;
+        if (endsAt !== void 0) input.endsAt = endsAt;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/description/mode/location/joinUrl/capacity/startsAt/endsAt/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_EVENT, { id, input });
+        return jsonResult(data.comUpdateEvent);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_transition")),
+    {
+      title: "Transition Event",
+      description: "Advance an event through its lifecycle (SCHEDULED \u2192 LIVE \u2192 COMPLETED; CANCELLED from any non-terminal state).",
+      inputSchema: {
+        id: zod.z.string().describe("Event ID"),
+        status: EventStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_EVENT, { id, status });
+        return jsonResult(data.comTransitionEvent);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_rsvp")),
+    {
+      title: "RSVP to Event",
+      description: "RSVP to an event as the calling member (idempotent \u2014 updates an existing RSVP). Returns the RSVP.",
+      inputSchema: {
+        eventId: zod.z.string().describe("Event ID"),
+        status: RsvpStatusEnum.describe("RSVP response"),
+        note: zod.z.string().optional().describe("Optional note to the host")
+      }
+    },
+    async ({ eventId, status, note }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RSVP_EVENT, { eventId, status, note });
+        return jsonResult(data.comRsvpEvent);
+      } catch (error) {
+        ctx.logger.error("comradecircle events_rsvp failed", { error: String(error) });
+        return errorResult(
+          `Failed to RSVP to event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPollTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "polls_get")),
+    {
+      title: "Get Poll",
+      description: "Fetch a single poll by ID, including its options and vote counts.",
+      inputSchema: { id: zod.z.string().describe("Poll ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_POLL, { id });
+        if (!data.comPoll) return errorResult(`Poll ${id} not found`);
+        return jsonResult(data.comPoll);
+      } catch (error) {
+        ctx.logger.error("comradecircle polls_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get poll: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "polls_list")),
+    {
+      title: "List Polls",
+      description: "List the polls in a circle, optionally filtered by status (OPEN/CLOSED).",
+      inputSchema: {
+        circleId: zod.z.string().describe("Circle ID"),
+        status: PollStatusEnum.optional().describe("Filter by poll status")
+      }
+    },
+    async ({ circleId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_POLLS, { circleId, status });
+        return jsonResult(data.comListPolls);
+      } catch (error) {
+        ctx.logger.error("comradecircle polls_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list polls: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "polls_create")),
+    {
+      title: "Create Poll",
+      description: "Create a poll in a circle with two or more options. `allowMultiple` and `isAnonymous` default to false.",
+      inputSchema: {
+        circleId: zod.z.string().min(1).describe("Host circle ID"),
+        question: zod.z.string().min(1).describe("Poll question"),
+        options: zod.z.array(zod.z.string()).min(2).describe("Option labels (at least two)"),
+        allowMultiple: zod.z.boolean().optional().describe("Allow selecting multiple options"),
+        isAnonymous: zod.z.boolean().optional().describe("Hide who voted for what"),
+        closesAt: zod.z.string().optional().describe("Auto-close time (ISO-8601 DateTime)")
+      }
+    },
+    async ({ circleId, question, options, allowMultiple, isAnonymous, closesAt }) => {
+      try {
+        const input = { circleId, question, options };
+        if (allowMultiple !== void 0) input.allowMultiple = allowMultiple;
+        if (isAnonymous !== void 0) input.isAnonymous = isAnonymous;
+        if (closesAt !== void 0) input.closesAt = closesAt;
+        const data = await ctx.gql.workspace.request(CREATE_POLL, { input });
+        return jsonResult(data.comCreatePoll);
+      } catch (error) {
+        ctx.logger.error("comradecircle polls_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create poll: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "polls_close")),
+    {
+      title: "Close Poll",
+      description: "Close a poll so no further votes can be cast. Returns the updated poll.",
+      inputSchema: { id: zod.z.string().describe("Poll ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CLOSE_POLL, { id });
+        return jsonResult(data.comClosePoll);
+      } catch (error) {
+        ctx.logger.error("comradecircle polls_close failed", { error: String(error) });
+        return errorResult(
+          `Failed to close poll: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "polls_vote")),
+    {
+      title: "Vote on Poll",
+      description: "Cast a vote for a poll option as the calling member (one vote per option). Returns the updated option.",
+      inputSchema: {
+        pollId: zod.z.string().describe("Poll ID"),
+        optionId: zod.z.string().describe("Poll option ID to vote for")
+      }
+    },
+    async ({ pollId, optionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VOTE_POLL, { pollId, optionId });
+        return jsonResult(data.comVotePoll);
+      } catch (error) {
+        ctx.logger.error("comradecircle polls_vote failed", { error: String(error) });
+        return errorResult(
+          `Failed to vote on poll: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/comradecircle/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Comradecircle Health Check",
+      description: "Public health probe for the Comradecircle subgraph (comHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.comHealth });
+      } catch (error) {
+        ctx.logger.error("comradecircle health failed", { error: String(error) });
+        return errorResult(
+          `Comradecircle health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/comradecircle/resources.ts
+function registerComradecircleResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const circlesUri = track(mcpResourceUri(ctx.productName, "circles"));
+  const feedUri = track(mcpResourceUri(ctx.productName, "feed"));
+  const profilesUri = track(mcpResourceUri(ctx.productName, "profiles"));
+  server.registerResource(
+    "comradecircle-schema",
+    schemaUri,
+    {
+      title: "Comradecircle Domain Schema",
+      description: "Overview of the Comradecircle community domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Comradecircle Domain (Overview)
+
+Unified social, communication & engagement platform for workspaces.
+
+## Entities
+- ComCircle \u2014 a community (channels, memberships, polls, events)
+- ComChannel \u2014 a channel within a circle (TEXT/VOICE/FORUM/ANNOUNCEMENT)
+- ComMembership \u2014 a member's membership of a circle (role + status)
+- ComProfile \u2014 a member's social profile (one per member per workspace)
+- ComPost (+ComComment, +ComReaction) \u2014 channel posts, threaded comments, typed reactions
+- ComFeedFollow \u2014 a follow edge feeding the unified home feed
+- ComEvent (+ComEventRsvp) \u2014 circle events + RSVPs
+- ComPoll (+ComPollOption) \u2014 circle polls + options/votes
+
+## Enums
+- ComCircleVisibility: PUBLIC, PRIVATE, SECRET
+- ComCircleStatus: ACTIVE, ARCHIVED, SUSPENDED
+- ComChannelType: TEXT, VOICE, FORUM, ANNOUNCEMENT
+- ComChannelVisibility: CIRCLE, PRIVATE
+- ComMemberRole: OWNER, ADMIN, MODERATOR, MEMBER
+- ComMembershipStatus: ACTIVE, PENDING, LEFT, BANNED
+- ComPostStatus: DRAFT, PUBLISHED, HIDDEN, REMOVED
+- ComReactionType: LIKE, LOVE, CELEBRATE, INSIGHTFUL, SUPPORT, LAUGH
+- ComFollowTargetType: CIRCLE, CHANNEL, MEMBER
+- ComEventMode: ONLINE, IN_PERSON, HYBRID
+- ComEventStatus: SCHEDULED, LIVE, COMPLETED, CANCELLED
+- ComRsvpStatus: GOING, INTERESTED, NOT_GOING, WAITLISTED
+- ComPollStatus: OPEN, CLOSED
+- ComPresence: ONLINE, AWAY, BUSY, OFFLINE
+
+## Tool groups
+circles, channels, memberships, profiles, posts, comments, feed, events, polls.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "comradecircle-circles",
+    circlesUri,
+    {
+      title: "Comradecircle Circle Directory",
+      description: "The first page of circles in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${circlesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CIRCLES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: circlesUri,
+              text: JSON.stringify(data.comListCircles, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: circlesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "comradecircle-feed",
+    feedUri,
+    {
+      title: "Comradecircle Home Feed",
+      description: "The calling member\u2019s unified home feed (first page).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${feedUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(MY_FEED, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: feedUri,
+              text: JSON.stringify(data.comMyFeed, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: feedUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "comradecircle-profiles",
+    profilesUri,
+    {
+      title: "Comradecircle Member Directory",
+      description: "The first page of discoverable member profiles in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${profilesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROFILES, {
+          discoverable: true,
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: profilesUri,
+              text: JSON.stringify(data.comListProfiles, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: profilesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerComradecirclePrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const setupName = track(mcpPromptName(p, "community-setup"));
+  const engagementName = track(mcpPromptName(p, "community-engagement"));
+  server.registerPrompt(
+    setupName,
+    {
+      title: "Community Setup",
+      description: "Guide for standing up a new Comradecircle community end to end: create the circle, add channels, set up your profile, and seed the first post.",
+      argsSchema: {
+        name: zod.z.string().optional().describe("Circle/community name"),
+        visibility: zod.z.string().optional().describe("Circle visibility (PUBLIC/PRIVATE/SECRET)")
+      }
+    },
+    ({ name, visibility }) => {
+      ctx.logger.debug(`Prompt ${setupName} called`, { name, visibility });
+      const nameNote = name ? `Use the community name "${name}".` : "Ask the user for the community name.";
+      const visibilityNote = visibility ? `Set visibility ${visibility}.` : "Help the user pick a visibility (PUBLIC, PRIVATE, or SECRET).";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me stand up a new Comradecircle community.
+
+1. **Create Circle**: Use ${p}_circles_create. ${nameNote} ${visibilityNote} Provide a unique slug; the caller becomes the OWNER.
+2. **Add Channels**: Use ${p}_channels_create for each channel \u2014 pick a type (TEXT/VOICE/FORUM/ANNOUNCEMENT) and a unique slug per circle. Start with a TEXT "general" and an ANNOUNCEMENT channel.
+3. **Set Up Profile**: Use ${p}_profiles_upsert to set your displayName, headline, interests, and skills.
+4. **Seed First Post**: Use ${p}_posts_create in the general channel to welcome members.
+5. **Verify**: Use ${p}_channels_list and ${p}_posts_list to confirm the setup.
+
+Show results at each step and confirm before posting.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    engagementName,
+    {
+      title: "Community Engagement",
+      description: "Daily engagement workflow: review the home feed, moderate posts, run events and polls, and grow the follow graph.",
+      argsSchema: {
+        circleId: zod.z.string().optional().describe("Circle ID to operate")
+      }
+    },
+    ({ circleId }) => {
+      ctx.logger.debug(`Prompt ${engagementName} called`, { circleId });
+      const circleNote = circleId ? `Operate circle "${circleId}".` : `First list circles with ${p}_circles_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily Comradecircle community engagement. ${circleNote}
+
+1. **Home Feed**: Use ${p}_feed_my to scan the latest activity from followed circles/channels/members.
+2. **Memberships**: Use ${p}_memberships_list to review the roster; use ${p}_memberships_set_role to promote moderators.
+3. **Moderate Posts**: Use ${p}_posts_list filtered by channel; pin highlights with ${p}_posts_update (isPinned=true) and hide/remove abuse with ${p}_posts_update (status=HIDDEN) or ${p}_posts_remove.
+4. **Engage**: Reply with ${p}_comments_add and acknowledge with ${p}_posts_react.
+5. **Events**: Use ${p}_events_list and ${p}_events_create to schedule meetups; advance live events with ${p}_events_transition.
+6. **Polls**: Use ${p}_polls_create to gather input; close stale ones with ${p}_polls_close.
+7. **Grow the Graph**: Use ${p}_feed_follow to follow active members and channels.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/comradecircle/index.ts
+var comradecircleModule = {
+  id: "comradecircle",
+  version: "0.0.1",
+  displayName: "Comradecircle",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerCircleTools(server, ctx, trackTool);
+    registerChannelTools(server, ctx, trackTool);
+    registerMembershipTools(server, ctx, trackTool);
+    registerProfileTools(server, ctx, trackTool);
+    registerPostTools(server, ctx, trackTool);
+    registerCommentTools(server, ctx, trackTool);
+    registerFeedTools(server, ctx, trackTool);
+    registerEventTools(server, ctx, trackTool);
+    registerPollTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerComradecircleResources(server, ctx, trackResource);
+    registerComradecirclePrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var comradecircle_default = comradecircleModule;
+
+module.exports = comradecircle_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map