loomiomcp 0.0.1

package/dist/index.js

@@ -0,0 +1,804 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/loomio/client.ts
+import { fetch } from "undici";
+
+// src/env.ts
+function readBool(name) {
+  const raw = process.env[name]?.toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+
+// src/log.ts
+import { AsyncLocalStorage } from "async_hooks";
+function logVerbose() {
+  return readBool("LOOMIO_MCP_LOG_VERBOSE");
+}
+var chainHandlers = {
+  "tool.call": (ctx, f) => {
+    if (typeof f["tool"] === "string") ctx.tools.push(f["tool"]);
+  },
+  "loomio.request": (ctx) => {
+    ctx.loomioCalls += 1;
+  }
+};
+function logEvent(event, fields, opts = {}) {
+  const ctx = requestContext.getStore();
+  if (ctx) chainHandlers[event]?.(ctx, fields);
+  if (!opts.force && !logVerbose()) return;
+  process.stderr.write(
+    `${JSON.stringify({ event, ...fields, timestamp: (/* @__PURE__ */ new Date()).toISOString() })}
+`
+  );
+}
+function redactPath(path) {
+  const noQuery = path.split("?")[0] ?? path;
+  return noQuery.replace(/\/\d+(?:,\d+)*/g, "/:id");
+}
+var requestContext = new AsyncLocalStorage();
+function getRequestContext() {
+  return requestContext.getStore();
+}
+
+// src/loomio/client.ts
+var DEFAULT_BASE_URL = "https://www.loomio.com/api";
+function baseUrl() {
+  const override = process.env["LOOMIO_API_BASE_URL"];
+  if (!override) return DEFAULT_BASE_URL;
+  if (!URL.canParse(override)) {
+    throw new LoomioAuthError(
+      `LOOMIO_API_BASE_URL is not a valid URL: ${JSON.stringify(override)}`
+    );
+  }
+  const u = new URL(override);
+  const isLocal = u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1";
+  if (u.protocol !== "https:" && !(u.protocol === "http:" && isLocal)) {
+    throw new LoomioAuthError(
+      `LOOMIO_API_BASE_URL must be https:// (or http:// on localhost); got ${u.protocol}//${u.hostname}. Sending the Loomio API key to that URL would expose it.`
+    );
+  }
+  return override;
+}
+function isReadOnly() {
+  return readBool("LOOMIO_MCP_READONLY");
+}
+var LoomioReadOnlyError = class extends Error {
+  constructor(method) {
+    super(
+      `loomiomcp is running in read-only mode (LOOMIO_MCP_READONLY is set). ${method} requests are refused. Unset LOOMIO_MCP_READONLY to enable writes.`
+    );
+    this.name = "LoomioReadOnlyError";
+  }
+};
+var LoomioAuthError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "LoomioAuthError";
+  }
+  status;
+};
+var LoomioApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "LoomioApiError";
+  }
+  status;
+};
+function getApiKey() {
+  const key = process.env["LOOMIO_API_KEY"];
+  if (!key) {
+    throw new LoomioAuthError(
+      "LOOMIO_API_KEY environment variable is not set. Generate one in Loomio under your profile \u2192 API keys."
+    );
+  }
+  return key;
+}
+function getB3ApiKey() {
+  const key = process.env["LOOMIO_B3_API_KEY"];
+  if (!key) {
+    throw new LoomioAuthError(
+      "LOOMIO_B3_API_KEY environment variable is not set. The b3 admin endpoints require a server-instance secret (ENV['B3_API_KEY'] on the Loomio server, >16 chars). Only Loomio instance operators have this."
+    );
+  }
+  return key;
+}
+function hasB3ApiKey() {
+  return Boolean(process.env["LOOMIO_B3_API_KEY"]);
+}
+function baseHeaders() {
+  return {
+    Accept: "application/json"
+  };
+}
+async function parseErrorBody(res) {
+  try {
+    const body = await res.json();
+    if (body.errors && typeof body.errors === "object") {
+      const parts = [];
+      for (const [field, msgs] of Object.entries(body.errors)) {
+        const msg = Array.isArray(msgs) ? msgs.join(", ") : String(msgs);
+        parts.push(`${field}: ${msg}`);
+      }
+      if (parts.length > 0) return parts.join("; ");
+    }
+    if (body.message) return body.message;
+    if (body.error) return body.error;
+    return res.statusText;
+  } catch {
+    return res.statusText;
+  }
+}
+var REQUEST_TIMEOUT_MS = 6e4;
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || /aborted/i.test(err.message));
+}
+function timeoutError() {
+  throw new LoomioApiError(
+    504,
+    `Loomio API request timed out after ${REQUEST_TIMEOUT_MS / 1e3}s. The Loomio API may be slow or hung; retry after a short wait.`
+  );
+}
+async function fetchWithTimeout(url, options) {
+  const hasCallerSignal = !!options && options.signal !== void 0;
+  const controller = hasCallerSignal ? void 0 : new AbortController();
+  const timer = controller && setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  timer?.unref();
+  const cleanup = () => {
+    if (timer) clearTimeout(timer);
+  };
+  const opts = controller ? { ...options ?? {}, signal: controller.signal } : options ?? {};
+  try {
+    const res = await fetch(url, opts);
+    return { res, cleanup };
+  } catch (err) {
+    cleanup();
+    if (isAbortError(err)) timeoutError();
+    throw err;
+  }
+}
+async function throwForStatus(res) {
+  if (res.status === 401 || res.status === 403) {
+    const detail = await parseErrorBody(res);
+    throw new LoomioAuthError(
+      `Loomio API returned ${res.status}: ${detail}. Check that LOOMIO_API_KEY is valid and has access to the requested resource.`,
+      res.status
+    );
+  }
+  if (!res.ok) {
+    const msg = await parseErrorBody(res);
+    throw new LoomioApiError(res.status, `Loomio API error ${res.status}: ${msg}`);
+  }
+}
+async function handleResponse(res) {
+  await throwForStatus(res);
+  try {
+    return await res.json();
+  } catch (err) {
+    if (isAbortError(err)) timeoutError();
+    throw err;
+  }
+}
+var B2_AUTH = { field: "api_key", getValue: getApiKey };
+var B3_AUTH = { field: "b3_api_key", getValue: getB3ApiKey };
+function buildUrl(auth, path, params) {
+  const url = new URL(`${baseUrl()}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  url.searchParams.set(auth.field, auth.getValue());
+  return url.toString();
+}
+async function doFetch(url, options) {
+  const startedAt = Date.now();
+  const method = options?.method ?? "GET";
+  const first = await fetchWithTimeout(url, options);
+  return { ...first, startedAt, method, url };
+}
+async function consumeBody(start, body) {
+  try {
+    return await body();
+  } finally {
+    emitLoomioRequest(start.method, start.url, start.res, Date.now() - start.startedAt);
+  }
+}
+function emitLoomioRequest(method, url, res, durationMs) {
+  let path = "";
+  try {
+    path = redactPath(new URL(url).pathname);
+  } catch {
+    path = "?";
+  }
+  const lenHeader = res.headers.get("content-length");
+  const responseBytes = lenHeader ? Number.parseInt(lenHeader, 10) : 0;
+  logEvent("loomio.request", {
+    method,
+    path,
+    status: res.status,
+    durationMs,
+    responseBytes: Number.isFinite(responseBytes) ? responseBytes : 0
+  });
+}
+async function loomioGet(path, params) {
+  const url = buildUrl(B2_AUTH, path, params);
+  const start = await doFetch(url, { headers: baseHeaders() });
+  try {
+    return await consumeBody(start, () => handleResponse(start.res));
+  } finally {
+    start.cleanup();
+  }
+}
+function encodeForm(body) {
+  const u = new URLSearchParams();
+  for (const [k, v] of Object.entries(body)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) u.append(`${k}[]`, String(item));
+    } else {
+      u.append(k, String(v));
+    }
+  }
+  return u.toString();
+}
+async function loomioPost(path, body, opts = {}) {
+  if (isReadOnly()) throw new LoomioReadOnlyError("POST");
+  const url = buildUrl(B2_AUTH, path, opts.params);
+  const encoding = opts.encoding ?? "json";
+  const start = await doFetch(url, {
+    method: "POST",
+    headers: {
+      ...baseHeaders(),
+      "Content-Type": encoding === "form" ? "application/x-www-form-urlencoded" : "application/json"
+    },
+    body: encoding === "form" ? encodeForm(body) : JSON.stringify(body)
+  });
+  try {
+    return await consumeBody(start, () => handleResponse(start.res));
+  } finally {
+    start.cleanup();
+  }
+}
+async function loomioPostB3(path, params) {
+  if (isReadOnly()) throw new LoomioReadOnlyError("POST");
+  const url = buildUrl(B3_AUTH, path, params);
+  const start = await doFetch(url, {
+    method: "POST",
+    headers: { ...baseHeaders(), "Content-Type": "application/json" },
+    body: "{}"
+  });
+  try {
+    return await consumeBody(start, () => handleResponse(start.res));
+  } finally {
+    start.cleanup();
+  }
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/icon.ts
+var ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="loomiomcp">
+  <!-- Placeholder mark: letter L on a tinted circle. Visually neutral \u2014
+       does not reproduce any Loomio trademark. -->
+  <circle cx="32" cy="32" r="28" fill="#2563EB"/>
+  <path d="M22 16 L22 48 L44 48 L44 42 L28 42 L28 16 Z" fill="#FFFFFF"/>
+</svg>`;
+var ICON_DATA_URI = `data:image/svg+xml;base64,${Buffer.from(ICON_SVG, "utf8").toString("base64")}`;
+var ICONS = [
+  {
+    src: ICON_DATA_URI,
+    mimeType: "image/svg+xml",
+    sizes: ["64x64", "any"]
+  }
+];
+
+// src/server/register-tool.ts
+var READ_PREFIXES = ["search_", "filter_", "get_", "list_", "show_", "run_"];
+function isReadOnlyByName(name) {
+  return READ_PREFIXES.some((p) => name.startsWith(p));
+}
+function isDestructive(name) {
+  return name.startsWith("delete_") || name === "manage_memberships" || name === "deactivate_user";
+}
+function inferAnnotations(name) {
+  const readOnly = isReadOnlyByName(name);
+  return {
+    readOnlyHint: readOnly,
+    destructiveHint: isDestructive(name),
+    idempotentHint: readOnly,
+    openWorldHint: true
+  };
+}
+function argFieldNames(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return [];
+  return Object.keys(input);
+}
+function emitToolCall(opts) {
+  logEvent("tool.call", {
+    tool: opts.tool,
+    ...opts.clientId ? { clientId: opts.clientId } : {},
+    argFields: opts.argFields,
+    durationMs: Date.now() - opts.startedAt,
+    outcome: opts.outcome
+  });
+}
+function wrapAsText(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+function registerTool(server2, name, description, schema, handler) {
+  const registerWithSchema = server2.registerTool.bind(server2);
+  registerWithSchema(
+    name,
+    { description, inputSchema: schema, annotations: inferAnnotations(name) },
+    async (input) => {
+      const startedAt = Date.now();
+      const argFields = argFieldNames(input);
+      const clientId = getRequestContext()?.clientId;
+      try {
+        const result = await handler(input);
+        emitToolCall({ tool: name, clientId, argFields, startedAt, outcome: "success" });
+        return wrapAsText(result);
+      } catch (err) {
+        emitToolCall({ tool: name, clientId, argFields, startedAt, outcome: "error" });
+        throw err;
+      }
+    }
+  );
+}
+
+// src/tools/discussions.ts
+import { z as z2 } from "zod";
+
+// src/tools/_common.ts
+import { z } from "zod";
+var positiveId = z.number().int().positive();
+var loomioKey = z.string().regex(/^[A-Za-z0-9_-]+$/, "Loomio short keys may only contain letters, numbers, _ and -.");
+var idOrKey = z.union([loomioKey, positiveId]);
+function encodePathSegment(value) {
+  const raw = String(value);
+  if (raw === "" || raw === "." || raw === "..") {
+    throw new Error("id_or_key must be a non-empty Loomio id or short key.");
+  }
+  return encodeURIComponent(raw);
+}
+var PollTypeEnum = z.enum([
+  "proposal",
+  "poll",
+  "count",
+  "score",
+  "ranked_choice",
+  "meeting",
+  "dot_vote"
+]);
+
+// src/tools/discussions.ts
+var getDiscussionSchema = z2.object({
+  id_or_key: idOrKey.describe(
+    "Discussion id (numeric) or short string key (e.g. 'abcDEF12'). Loomio accepts either."
+  )
+});
+async function getDiscussion(input) {
+  return loomioGet(`/b2/discussions/${encodePathSegment(input.id_or_key)}`);
+}
+var listDiscussionsSchema = z2.object({
+  group_id: positiveId.describe("ID of the Loomio group whose discussions to list (required)."),
+  status: z2.enum(["open", "closed", "all"]).optional().describe(
+    "Filter by status. 'open' = unlocked, 'closed' = locked, 'all' = every kept discussion. Loomio defaults to 'open'."
+  ),
+  limit: z2.number().int().min(1).max(200).optional().describe("Page size. Loomio defaults to 50."),
+  offset: z2.number().int().min(0).optional().describe("Page offset. Defaults to 0.")
+});
+async function listDiscussions(input) {
+  return loomioGet("/b2/discussions", {
+    group_id: input.group_id,
+    ...input.status ? { status: input.status } : {},
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.offset !== void 0 ? { offset: input.offset } : {}
+  });
+}
+var createDiscussionSchema = z2.object({
+  title: z2.string().min(1).describe("Discussion title (required)."),
+  group_id: positiveId.describe("ID of the Loomio group to create the discussion in (required)."),
+  description: z2.string().optional().describe("Optional discussion body."),
+  description_format: z2.enum(["md", "html"]).optional().describe("Format of `description`. Defaults to Loomio's group default when omitted."),
+  private: z2.boolean().optional().describe(
+    "Visibility: true = group members only, false = publicly visible. Loomio's validator enforces this against the group's `discussion_privacy_options`: `public_only` requires `private: false`, `private_only` requires `private: true`, `public_or_private` allows either. When omitted, the connector reads the group's setting and chooses the value Loomio's web UI would pick: `false` for `public_only`, `true` otherwise (matching `Group#discussion_private_default`). Pass an explicit value to override."
+  ),
+  recipient_audience: z2.enum(["group"]).optional().describe("Audience selector for notification recipients. 'group' = notify whole group."),
+  recipient_user_ids: z2.array(positiveId).optional().describe("Explicit list of user IDs to notify."),
+  recipient_emails: z2.array(z2.string().email()).optional().describe("Explicit list of email addresses to notify."),
+  recipient_message: z2.string().optional().describe("Optional custom message to include in notifications.")
+});
+async function resolveDiscussionPrivate(groupId) {
+  try {
+    const resp = await loomioGet(`/v1/groups/${groupId}`);
+    const opts = resp.groups?.[0]?.discussion_privacy_options;
+    return opts !== "public_only";
+  } catch (err) {
+    if ((err instanceof LoomioAuthError || err instanceof LoomioApiError) && err.status === 403) {
+      return true;
+    }
+    throw err;
+  }
+}
+async function createDiscussion(input) {
+  if (isReadOnly()) throw new LoomioReadOnlyError("POST");
+  const priv = input.private !== void 0 ? input.private : await resolveDiscussionPrivate(input.group_id);
+  return loomioPost("/b2/discussions", { ...input, private: priv });
+}
+
+// src/tools/polls.ts
+import { z as z3 } from "zod";
+var getPollSchema = z3.object({
+  id_or_key: idOrKey.describe("Poll id (numeric) or short string key.")
+});
+async function getPoll(input) {
+  return loomioGet(`/b2/polls/${encodePathSegment(input.id_or_key)}`);
+}
+var listPollsSchema = z3.object({
+  group_id: positiveId.describe("ID of the Loomio group whose polls to list (required)."),
+  status: z3.enum(["active", "closed", "all"]).optional().describe("Filter polls by status. Loomio defaults to 'active'."),
+  limit: z3.number().int().min(1).max(200).optional().describe("Page size. Loomio defaults to 50."),
+  offset: z3.number().int().min(0).optional().describe("Page offset. Defaults to 0.")
+});
+async function listPolls(input) {
+  return loomioGet("/b2/polls", {
+    group_id: input.group_id,
+    ...input.status ? { status: input.status } : {},
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.offset !== void 0 ? { offset: input.offset } : {}
+  });
+}
+var createPollSchema = z3.object({
+  title: z3.string().min(1).describe("Poll title (required)."),
+  poll_type: PollTypeEnum.describe(
+    "Poll type. One of: proposal, poll, count, score, ranked_choice, meeting, dot_vote."
+  ),
+  group_id: positiveId.optional().describe(
+    "Group the poll belongs to. Required when not attaching to an existing discussion via discussion_id."
+  ),
+  discussion_id: positiveId.optional().describe(
+    "Attach the poll to an existing discussion. When set, group_id is taken from the discussion."
+  ),
+  details: z3.string().optional().describe("Optional poll body / context."),
+  details_format: z3.enum(["md", "html"]).optional().describe("Format of `details`. Defaults to 'md'."),
+  options: z3.array(z3.string().min(1)).optional().describe(
+    "Voting options. `proposal` has built-in agree/disagree/abstain options; for poll / count / score / ranked_choice / meeting / dot_vote you MUST supply your own."
+  ),
+  closing_at: z3.string().optional().describe("ISO-8601 timestamp at which the poll closes."),
+  specified_voters_only: z3.boolean().optional().describe("If true, only users in recipient_user_ids / recipient_emails can vote."),
+  hide_results: z3.enum(["off", "until_vote", "until_closed"]).optional().describe("Results visibility policy. Defaults to 'off'."),
+  shuffle_options: z3.boolean().optional().describe("If true, shuffle option display order."),
+  anonymous: z3.boolean().optional().describe("If true, hide voter identities."),
+  recipient_audience: z3.enum(["group"]).optional(),
+  notify_on_closing_soon: z3.enum(["nobody", "author", "voters", "undecided_voters", "all_members"]).optional().describe("Who Loomio notifies as the closing date approaches. Defaults to 'nobody'."),
+  recipient_user_ids: z3.array(positiveId).optional(),
+  recipient_emails: z3.array(z3.string().email()).optional(),
+  recipient_message: z3.string().optional(),
+  notify_recipients: z3.boolean().optional().describe("If false, suppress the initial notification email. Defaults to false.")
+}).superRefine((input, ctx) => {
+  if (input.group_id === void 0 && input.discussion_id === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["group_id"],
+      message: "Either group_id or discussion_id is required."
+    });
+  }
+  if (input.poll_type !== "proposal" && !input.options?.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["options"],
+      message: "options is required for non-proposal poll types."
+    });
+  }
+});
+async function createPoll(input) {
+  return loomioPost("/b2/polls", input);
+}
+
+// src/tools/memberships.ts
+import { z as z4 } from "zod";
+var listMembershipsSchema = z4.object({
+  group_id: positiveId.describe(
+    "ID of the Loomio group whose memberships to list (required). Caller must be a group admin; the response includes member email addresses."
+  ),
+  limit: z4.number().int().min(1).max(200).optional().describe("Page size. Loomio defaults to 50."),
+  offset: z4.number().int().min(0).optional().describe("Page offset. Defaults to 0.")
+});
+async function listMemberships(input) {
+  return loomioGet("/b2/memberships", {
+    group_id: input.group_id,
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.offset !== void 0 ? { offset: input.offset } : {}
+  });
+}
+var manageMembershipsSchema = z4.object({
+  group_id: positiveId.describe(
+    "ID of the Loomio group to modify (required). Caller must be a group admin."
+  ),
+  emails: z4.array(z4.string().email()).min(1).describe(
+    "Email addresses to ensure are members. Each address that isn't already a member is invited / added."
+  ),
+  remove_absent: z4.boolean().optional().describe(
+    "DANGEROUS. When true, Loomio REMOVES every existing member whose email is NOT in `emails`. Empty-emails (after dedupe) effectively removes the entire group. Default false. Only set true after reading list_memberships and confirming the diff with a human."
+  )
+});
+async function manageMemberships(input) {
+  return loomioPost("/b2/memberships", input);
+}
+
+// src/tools/groups.ts
+import { z as z5 } from "zod";
+var DEFAULT_START_ID = 1;
+var DEFAULT_END_ID = 200;
+var MAX_END_ID = 1e4;
+var MAX_PROBE_SPAN = 500;
+var CONCURRENCY = 5;
+var listGroupsSchema = z5.object({
+  start_id: z5.number().int().min(1).optional().describe("First group_id to probe (inclusive). Defaults to 1."),
+  end_id: z5.number().int().min(1).max(MAX_END_ID).optional().describe(
+    "Last group_id to probe (inclusive). Defaults to 200. A single call may scan at most 500 ids; use multiple calls for wider ranges."
+  ),
+  stop_after_consecutive_misses: z5.number().int().min(1).max(MAX_PROBE_SPAN).optional().describe(
+    "Early-exit heuristic: stop probing after this many consecutive 404/403 misses. Saves wall time on sparse id ranges. Defaults to 50."
+  )
+}).superRefine((input, ctx) => {
+  const start = input.start_id ?? DEFAULT_START_ID;
+  const end = input.end_id ?? DEFAULT_END_ID;
+  if (end < start) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["end_id"],
+      message: "end_id must be greater than or equal to start_id."
+    });
+    return;
+  }
+  if (end - start + 1 > MAX_PROBE_SPAN) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["end_id"],
+      message: `A single list_groups call may scan at most ${MAX_PROBE_SPAN} ids.`
+    });
+  }
+});
+async function probeOne(id) {
+  try {
+    const resp = await loomioGet("/b2/polls", {
+      group_id: id,
+      limit: 1,
+      status: "all"
+    });
+    return { id, groups: resp.groups ?? [] };
+  } catch (err) {
+    if (err instanceof LoomioApiError && err.status === 404) return { id, groups: [] };
+    if (err instanceof LoomioAuthError && err.status === 403) return { id, groups: [] };
+    throw err;
+  }
+}
+function slim(g) {
+  return {
+    id: g.id,
+    key: g.key,
+    handle: g.handle,
+    name: g.name,
+    parent_id: g.parent_id,
+    discussion_privacy_options: g.discussion_privacy_options,
+    is_visible_to_public: g.is_visible_to_public,
+    memberships_count: g.memberships_count
+  };
+}
+async function listGroups(input) {
+  const parsed = listGroupsSchema.parse(input);
+  const start = parsed.start_id ?? DEFAULT_START_ID;
+  const end = parsed.end_id ?? DEFAULT_END_ID;
+  const maxMisses = parsed.stop_after_consecutive_misses ?? 50;
+  const seenIds = /* @__PURE__ */ new Set();
+  const found = [];
+  let consecutiveMisses = 0;
+  let earlyExit = false;
+  let lastScanned = start - 1;
+  for (let batchStart = start; batchStart <= end; batchStart += CONCURRENCY) {
+    const ids = [];
+    for (let id = batchStart; id < batchStart + CONCURRENCY && id <= end; id++) {
+      ids.push(id);
+    }
+    const results = await Promise.all(ids.map((id) => probeOne(id)));
+    for (const r of results) {
+      lastScanned = r.id;
+      if (r.groups.length > 0) {
+        for (const g of r.groups) {
+          if (!seenIds.has(g.id)) {
+            seenIds.add(g.id);
+            found.push(slim(g));
+          }
+        }
+        consecutiveMisses = 0;
+      } else {
+        consecutiveMisses++;
+      }
+    }
+    if (consecutiveMisses >= maxMisses) {
+      earlyExit = true;
+      break;
+    }
+  }
+  return {
+    groups: found,
+    scanned: {
+      from: start,
+      to: lastScanned,
+      stopped_early: earlyExit,
+      total_found: found.length
+    }
+  };
+}
+
+// src/tools/comments.ts
+import { z as z6 } from "zod";
+var createCommentSchema = z6.object({
+  discussion_id: positiveId.describe("ID of the discussion to comment on."),
+  body: z6.string().min(1).describe("Comment body (required)."),
+  body_format: z6.enum(["md", "html"]).optional().describe("Format of `body`. Defaults to Loomio's group default when omitted.")
+});
+async function createComment(input) {
+  const { discussion_id, ...rest } = input;
+  return loomioPost("/b2/comments", rest, {
+    params: { discussion_id },
+    encoding: "form"
+  });
+}
+
+// src/tools/admin.ts
+import { z as z7 } from "zod";
+var deactivateUserSchema = z7.object({
+  id: positiveId.describe("Loomio user id to deactivate. Returns 404 if not active.")
+});
+async function deactivateUser(input) {
+  return loomioPostB3("/b3/users/deactivate", { id: input.id });
+}
+var reactivateUserSchema = z7.object({
+  id: positiveId.describe(
+    "Loomio user id to reactivate. Returns 404 if not currently deactivated."
+  )
+});
+async function reactivateUser(input) {
+  return loomioPostB3("/b3/users/reactivate", { id: input.id });
+}
+
+// src/server.ts
+function createLoomioMcpServer() {
+  const readOnly = isReadOnly();
+  const b3Enabled = hasB3ApiKey();
+  const server2 = new McpServer({
+    name: "loomiomcp",
+    version: "0.1.0",
+    description: "MCP server for Loomio (loomio.com / self-hosted). Wraps Loomio's b2 public API: read and create discussions, polls, comments, plus list and manage group memberships. Read-only mode supported via LOOMIO_MCP_READONLY=1 (Cloud Run pattern). Optional b3 admin operations (deactivate / reactivate user) when LOOMIO_B3_API_KEY is set \u2014 instance operators only. Read tools annotated with readOnlyHint so MCP clients can auto-approve safe calls; destructive writes (manage_memberships with remove_absent, deactivate_user) carry destructiveHint.",
+    websiteUrl: "https://github.com/soil-dev/loomiomcp",
+    icons: ICONS
+  });
+  registerTool(
+    server2,
+    "get_discussion",
+    "Fetch a single Loomio discussion (thread) by id or short string key. Returns the full record \u2014 title, description, group, author, ranges/last-activity timestamps, and embedded users \u2014 in one round-trip. Use for 'show me discussion X', 'what's in thread Y', or to resolve an id_or_key referenced by another tool's output. To enumerate a group's discussions instead of fetching one, use list_discussions.",
+    getDiscussionSchema,
+    getDiscussion
+  );
+  registerTool(
+    server2,
+    "list_discussions",
+    "List discussions in a Loomio group, ordered by latest activity. Required: `group_id`. Optional `status` filter \u2014 'open' (unlocked, default), 'closed' (locked), 'all' (every kept thread); `limit` 1-200 (Loomio default 50); `offset` for pagination. Caller must be a group member. Use to answer 'what's being discussed in group X', 'show me recent threads', or before create_discussion to check for duplicates. For one specific thread, use get_discussion.",
+    listDiscussionsSchema,
+    listDiscussions
+  );
+  if (!readOnly) {
+    registerTool(
+      server2,
+      "create_discussion",
+      "Create a new Loomio discussion (thread) in a group. Required: `title`, `group_id`. The `private` field is auto-resolved from the group's `discussion_privacy_options` when omitted (matches Loomio's web UI default \u2014 public_only \u2192 false, anything else \u2192 true); pass it explicitly to override. Optional `description` + `description_format` ('md' / 'html') set the body. Notification recipients can be specified via `recipient_audience: 'group'` (notify all members), `recipient_user_ids` (explicit user ids), or `recipient_emails` (invite new people), optionally with a `recipient_message`. Caller must be allowed to start discussions in the group.",
+      createDiscussionSchema,
+      createDiscussion
+    );
+  }
+  registerTool(
+    server2,
+    "get_poll",
+    "Fetch a single Loomio poll (proposal / vote / multi-choice / score / ranked_choice / meeting / dot_vote) by id or short string key. Returns the poll record \u2014 title, type, options, closing state, voter visibility settings, and embedded author. Use for 'show me poll X', 'what's the result of Y', or to follow up on a poll id referenced elsewhere. To enumerate a group's polls, use list_polls.",
+    getPollSchema,
+    getPoll
+  );
+  registerTool(
+    server2,
+    "list_polls",
+    "List polls in a Loomio group, ordered by creation date (newest first). Required: `group_id`. Optional `status` filter \u2014 'active' (default), 'closed', 'all' (every kept poll); `limit` 1-200 (default 50); `offset` for pagination. Caller must be a group member. Use to answer 'what's up for vote in group X', 'show me past poll results', or before create_poll to check what's already proposed.",
+    listPollsSchema,
+    listPolls
+  );
+  if (!readOnly) {
+    registerTool(
+      server2,
+      "create_poll",
+      "Create a new Loomio poll. Required: `title`, `poll_type` \u2014 one of 'proposal' (built-in agree / disagree / abstain), 'poll' (single-choice), 'count' (count signers), 'score' (1-5 rating, configurable via min_score / max_score), 'ranked_choice' (STV), 'meeting' (time poll), 'dot_vote' (point allocation, see dots_per_person). For every type except 'proposal' you MUST supply `options` (array of strings). Either supply `group_id` for a standalone poll or `discussion_id` to attach to an existing thread. Optional: `details` + `details_format`, `closing_at` (ISO-8601), `anonymous`, `hide_results` ('off' / 'until_vote' / 'until_closed'), `specified_voters_only`, `shuffle_options`, `notify_on_closing_soon`, recipient fields. KNOWN UPSTREAM LIMITATION: Loomio's b2 `permitted_params` omits `:private`, so the auto-created Topic always defaults to `private: true` and groups with public-discussions-only policy reject the create with a 422 and empty errors hash. See NOTES-ON-LOOMIO-API.md. Workaround at the moment: create polls only in groups that allow private discussions.",
+      createPollSchema,
+      createPoll
+    );
+  }
+  registerTool(
+    server2,
+    "list_memberships",
+    "List members of a Loomio group with their email addresses, roles, and join state. Required: `group_id`. Caller MUST be a group admin (non-admins get HTTP 403; the response is server-side scoped to include `include_email: true`). Optional `limit` 1-200 (default 50) and `offset` for pagination. Use to answer 'who's in group X', 'find a member by email', or \u2014 critically \u2014 BEFORE calling manage_memberships with remove_absent=true, since the diff between current and intended members is what makes that destructive call safe.",
+    listMembershipsSchema,
+    listMemberships
+  );
+  registerTool(
+    server2,
+    "list_groups",
+    "List groups the connector's api-key user can see, by probing a group_id range. Loomio's API has no native 'list groups' endpoint that honours api-key auth (v1's profile/groups needs a session; the v1 explore endpoint returns only public groups). This tool works around that by issuing one `b2/polls?group_id=N&limit=1&status=all` per id and collecting the group objects from the 200 responses \u2014 404s skipped, 403s treated as soft misses. Scope: returns every group the bot is a **member** of (plus their parent groups, which b2/polls embeds in the response). Bot users with `is_admin: true` bypass the membership check and see every group on the instance. Optional knobs: `start_id` (default 1), `end_id` (default 200; a single call may scan at most 500 ids), `stop_after_consecutive_misses` (default 50; early-exit on sparse id ranges). Caveat: this is the right tool to answer 'what groups can you see' and similar discovery questions, but it costs O(end_id - start_id) outbound calls \u2014 typically ~50\u2013200 HTTP requests in 2\u20135 seconds. The returned group objects are slimmed to `{id, key, handle, name, parent_id, discussion_privacy_options, is_visible_to_public, memberships_count}`; to drill in, use `list_memberships`, `list_discussions`, `list_polls` with the relevant id.",
+    listGroupsSchema,
+    listGroups
+  );
+  if (!readOnly) {
+    registerTool(
+      server2,
+      "manage_memberships",
+      "Invite users to a Loomio group by email and (optionally) REMOVE members not in the supplied list. Required: `group_id` (caller must be a group admin), `emails` (array of email addresses). Default mode is additive: every address in `emails` that isn't already a member is invited / added; no existing member is touched. DANGEROUS OPTION \u2014 `remove_absent: true`: Loomio REMOVES every existing group member whose email is NOT in `emails`. The zero-or-stale-emails case can wipe the entire group. There is no server-side dry-run and no undo. ALWAYS call list_memberships first, compute the diff explicitly, and confirm with a human before invoking with remove_absent=true. Returns `{added_emails: [...], removed_emails: [...]}` listing exactly what changed.",
+      manageMembershipsSchema,
+      manageMemberships
+    );
+  }
+  if (!readOnly) {
+    registerTool(
+      server2,
+      "create_comment",
+      "Post a comment (reply) on an existing Loomio discussion. Required: `discussion_id`, `body`. Optional `body_format` ('md' or 'html'; defaults to the group's setting). Caller must be permitted to post in the discussion's group. Use for 'reply to thread X', 'add a follow-up to discussion Y', or to chain a series of automated updates. For starting a new thread instead, use create_discussion.",
+      createCommentSchema,
+      createComment
+    );
+  }
+  if (b3Enabled && !readOnly) {
+    registerTool(
+      server2,
+      "deactivate_user",
+      "INSTANCE-ADMIN. Deactivate a Loomio user account instance-wide by user id. Required: `id` (numeric Loomio user id). Authenticates using `LOOMIO_B3_API_KEY` (matched against `ENV['B3_API_KEY']` on the Loomio server; \u226517 chars). This secret authenticates the SERVER, not the calling user \u2014 only set LOOMIO_B3_API_KEY if you operate the Loomio instance and have already deployed loomiomcp in a single-tenant context. Schedules an async DeactivateUserWorker that revokes sessions, memberships, and email subscriptions. Reversible via reactivate_user as long as the user record persists. Returns 404 if the user is not currently active.",
+      deactivateUserSchema,
+      deactivateUser
+    );
+    registerTool(
+      server2,
+      "reactivate_user",
+      "INSTANCE-ADMIN. Reactivate a previously-deactivated Loomio user by id. Required: `id`. Authenticates with LOOMIO_B3_API_KEY (server-instance admin secret \u2014 see deactivate_user). Restores the user's ability to log in, but does NOT restore prior memberships or subscriptions; those must be re-applied separately. Returns 404 if the user is not currently deactivated.",
+      reactivateUserSchema,
+      reactivateUser
+    );
+  }
+  return server2;
+}
+
+// src/index.ts
+if (!process.env["LOOMIO_API_KEY"]) {
+  console.error(
+    "[loomiomcp] LOOMIO_API_KEY environment variable is not set. Generate one in Loomio under your profile \u2192 API keys."
+  );
+  process.exit(1);
+}
+var server = createLoomioMcpServer();
+var transport = new StdioServerTransport();
+if (isReadOnly()) {
+  console.error("[loomiomcp] read-only mode: write tools are not registered");
+}
+try {
+  await server.connect(transport);
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`[loomiomcp] Failed to start: ${message}`);
+  process.exit(1);
+}