signupgenius-mcp 1.0.0

package/dist/client.js

@@ -0,0 +1,190 @@
+import { sessionLogin as defaultSessionLogin } from './session-login.js';
+export class SignUpGeniusClient {
+    account;
+    accessToken = null;
+    cookieHeader = null;
+    refreshInFlight = null;
+    sessionLoginFn;
+    constructor(account, opts = {}) {
+        this.account = account;
+        this.sessionLoginFn = opts.sessionLogin ?? defaultSessionLogin;
+    }
+    describe() {
+        return { name: this.account.name, mode: this.account.mode, baseUrl: this.account.baseUrl };
+    }
+    /** Account mode shorthand for tool registration logic. */
+    get mode() {
+        return this.account.mode;
+    }
+    async request(path, opts = {}) {
+        if (this.account.mode === 'session' && opts.legacyAction) {
+            return this.requestLegacy(opts.legacyAction, opts);
+        }
+        return this.requestApi(path, opts);
+    }
+    /** Throws if the current mode can't satisfy the call — e.g. Pro-only reports. */
+    requireMode(mode, featureLabel) {
+        if (this.account.mode !== mode) {
+            throw new ModeMismatchError(this.account.mode, mode, featureLabel);
+        }
+    }
+    async requestApi(path, opts) {
+        const acct = this.account;
+        const normalizedPath = path.endsWith('/') ? path : `${path}/`;
+        const params = new URLSearchParams();
+        if (acct.mode === 'key')
+            params.set('user_key', acct.userKey);
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v !== undefined)
+                params.set(k, String(v));
+        }
+        const qs = params.toString();
+        const url = `${acct.baseUrl}${normalizedPath}${qs ? `?${qs}` : ''}`;
+        const res = await this.authedFetch(url, {
+            method: opts.method ?? 'GET',
+            body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+            headers: opts.body !== undefined ? { 'Content-Type': 'application/json' } : undefined,
+        });
+        return parseEnvelope(res, path, normalizeKeyShape);
+    }
+    async requestLegacy(action, opts) {
+        // `request()` only routes here in session mode — narrow the union.
+        const acct = this.account;
+        const url = `${acct.legacyBaseUrl}/SUGboxAPI.cfm?go=${encodeURIComponent(action)}`;
+        const res = await this.authedFetch(url, {
+            method: 'POST',
+            body: JSON.stringify(opts.body ?? {}),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        return parseEnvelope(res, action, normalizeLegacyShape);
+    }
+    /**
+     * Fetch with auth attached. Session mode logs in lazily on first call and
+     * re-mints credentials transparently on a 401. Key mode is stateless.
+     */
+    async authedFetch(url, init, isRetry = false) {
+        await this.ensureAuth();
+        const res = await fetch(url, {
+            method: init.method,
+            headers: { Accept: 'application/json', ...(init.headers ?? {}), ...this.authHeaders() },
+            body: init.body,
+        });
+        if (res.status === 401 && this.account.mode === 'session' && !isRetry) {
+            await this.ensureAuth({ force: true });
+            return this.authedFetch(url, init, true);
+        }
+        return res;
+    }
+    authHeaders() {
+        if (this.account.mode === 'session') {
+            return { Authorization: `Bearer ${this.accessToken}`, Cookie: this.cookieHeader };
+        }
+        return {}; // key mode: user_key is in the query string
+    }
+    async ensureAuth(opts = {}) {
+        if (this.account.mode !== 'session')
+            return;
+        if (!opts.force && this.accessToken && this.cookieHeader)
+            return;
+        if (this.refreshInFlight)
+            return this.refreshInFlight;
+        const acct = this.account;
+        this.refreshInFlight = (async () => {
+            const result = await this.sessionLoginFn({
+                loginUrl: acct.loginBaseUrl,
+                email: acct.email,
+                password: acct.password,
+            });
+            this.accessToken = result.accessToken;
+            this.cookieHeader = result.cookieHeader;
+        })();
+        try {
+            await this.refreshInFlight;
+        }
+        finally {
+            this.refreshInFlight = null;
+        }
+    }
+}
+const normalizeKeyShape = (raw) => {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    return { data: r.data, message: r.message ?? [], success: r.success ?? false };
+};
+const normalizeLegacyShape = (raw) => {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    const m = r.MESSAGE;
+    return {
+        data: r.DATA,
+        message: Array.isArray(m) ? m : m ? [m] : [],
+        success: r.SUCCESS ?? false,
+    };
+};
+async function parseEnvelope(res, context, normalize) {
+    const text = await res.text();
+    const raw = parseJsonBody(text);
+    const parsed = raw !== null ? normalize(raw) : null;
+    const msg = parsed?.message.join('; ');
+    if (res.status === 401 || res.status === 403)
+        throw new AuthError(res.status, msg);
+    if (res.status === 404)
+        throw new Error(`SignUpGenius 404 ${context}`);
+    if (res.status >= 500)
+        throw new UnreachableError(res.status);
+    if (!res.ok)
+        throw new Error(`SignUpGenius ${res.status} ${msg || res.statusText} for ${context}`);
+    if (!parsed) {
+        throw new Error(`SignUpGenius returned ${text === '' ? 'empty' : 'non-JSON'} body for ${context}`);
+    }
+    if (!parsed.success) {
+        throw new Error(`SignUpGenius error: ${msg && msg.length > 0 ? msg : 'unknown'}`);
+    }
+    return parsed;
+}
+function parseJsonBody(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export class AuthError extends Error {
+    status;
+    constructor(status, detail) {
+        super(`SignUpGenius rejected the request (${status}). ` +
+            'For key mode: check SIGNUPGENIUS_USER_KEY (it may be wrong, revoked, or the account no longer has Pro). ' +
+            'For session mode: the session cookie may have been invalidated server-side.' +
+            (detail ? ` (${detail})` : ''));
+        this.status = status;
+        this.name = 'AuthError';
+    }
+}
+export class UnreachableError extends Error {
+    status;
+    constructor(status) {
+        super(`SignUpGenius unreachable (status ${status})`);
+        this.status = status;
+        this.name = 'UnreachableError';
+    }
+}
+export class ModeMismatchError extends Error {
+    currentMode;
+    requiredMode;
+    feature;
+    constructor(currentMode, requiredMode, feature) {
+        super(`${feature} requires ${requiredMode} mode but the server is running in ${currentMode} mode. ` +
+            (requiredMode === 'key'
+                ? 'Set SIGNUPGENIUS_USER_KEY (Pro subscription required for the documented v2/k API).'
+                : 'Set SIGNUPGENIUS_EMAIL + SIGNUPGENIUS_PASSWORD to enable this tool.'));
+        this.currentMode = currentMode;
+        this.requiredMode = requiredMode;
+        this.feature = feature;
+        this.name = 'ModeMismatchError';
+    }
+}

package/dist/config.js

@@ -0,0 +1,75 @@
+const DEFAULT_KEY_BASE_URL = 'https://api.signupgenius.com/v2/k';
+const DEFAULT_V3_BASE_URL = 'https://api.signupgenius.com/v3';
+const DEFAULT_LEGACY_BASE_URL = 'https://www.signupgenius.com';
+const DEFAULT_LOGIN_BASE_URL = 'https://www.signupgenius.com';
+/**
+ * Read an env var and treat empty/placeholder values as unset. Some MCP hosts
+ * stringify undefined user_config refs (Claude Desktop emits the literal
+ * "undefined"; others leave the `${user_config.foo}` placeholder intact), and
+ * a Bearer-style header built from those would silently authenticate as the
+ * wrong identity or fail upstream with a confusing 403.
+ */
+function readVar(env, key) {
+    const raw = env[key];
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (trimmed === 'undefined' || trimmed === 'null')
+        return undefined;
+    if (/^\$\{[^}]*\}$/.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+function requireHttps(value, varName) {
+    if (!/^https:\/\//.test(value)) {
+        throw new Error(`${varName} must be an https URL, got: '${value}'`);
+    }
+    return value.replace(/\/$/, '');
+}
+export function loadAccount(env = process.env) {
+    const userKey = readVar(env, 'SIGNUPGENIUS_USER_KEY');
+    const email = readVar(env, 'SIGNUPGENIUS_EMAIL');
+    const password = readVar(env, 'SIGNUPGENIUS_PASSWORD');
+    const hasFullSession = !!email && !!password;
+    const hasPartialSession = (!!email) !== (!!password);
+    // Precedence: explicit user_key wins (the documented Pro path). Surface a
+    // warning when both modes are configured so the user knows which one is
+    // actually being used.
+    if (userKey) {
+        const baseUrlRaw = readVar(env, 'SIGNUPGENIUS_BASE_URL') ?? DEFAULT_KEY_BASE_URL;
+        const baseUrl = requireHttps(baseUrlRaw, 'SIGNUPGENIUS_BASE_URL');
+        const name = readVar(env, 'SIGNUPGENIUS_NAME') ?? new URL(baseUrl).host;
+        if (hasFullSession) {
+            console.error('[signupgenius-mcp] SIGNUPGENIUS_USER_KEY takes precedence over SIGNUPGENIUS_EMAIL/PASSWORD — using key mode. ' +
+                'Unset the key to use session mode.');
+        }
+        else if (hasPartialSession) {
+            console.error(`[signupgenius-mcp] Ignoring partial session credentials (only ${email ? 'EMAIL' : 'PASSWORD'} set) — using SIGNUPGENIUS_USER_KEY.`);
+        }
+        return { mode: 'key', name, baseUrl, userKey };
+    }
+    if (hasPartialSession) {
+        const missing = email ? 'SIGNUPGENIUS_PASSWORD' : 'SIGNUPGENIUS_EMAIL';
+        throw new Error(`Incomplete session config — missing: ${missing}. ` +
+            'Set both SIGNUPGENIUS_EMAIL and SIGNUPGENIUS_PASSWORD, or use SIGNUPGENIUS_USER_KEY instead.');
+    }
+    if (hasFullSession) {
+        const baseUrl = requireHttps(readVar(env, 'SIGNUPGENIUS_BASE_URL') ?? DEFAULT_V3_BASE_URL, 'SIGNUPGENIUS_BASE_URL');
+        const legacyBaseUrl = requireHttps(readVar(env, 'SIGNUPGENIUS_LEGACY_BASE_URL') ?? DEFAULT_LEGACY_BASE_URL, 'SIGNUPGENIUS_LEGACY_BASE_URL');
+        const loginBaseUrl = requireHttps(readVar(env, 'SIGNUPGENIUS_LOGIN_URL') ?? DEFAULT_LOGIN_BASE_URL, 'SIGNUPGENIUS_LOGIN_URL');
+        const name = readVar(env, 'SIGNUPGENIUS_NAME') ?? email;
+        return {
+            mode: 'session',
+            name,
+            baseUrl,
+            legacyBaseUrl,
+            loginBaseUrl,
+            email: email,
+            password: password,
+        };
+    }
+    throw new Error('Missing SignUpGenius auth config. Set SIGNUPGENIUS_USER_KEY (Pro API), ' +
+        'or SIGNUPGENIUS_EMAIL + SIGNUPGENIUS_PASSWORD (session mode, free accounts).');
+}

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+try {
+    const { config } = await import('dotenv');
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    // quiet:true suppresses dotenv's startup banner — MCP uses stdout for
+    // JSON-RPC, and any extra output corrupts the stream.
+    config({ path: join(__dirname, '..', '.env'), override: false, quiet: true });
+}
+catch {
+    // dotenv not available — rely on process.env
+}
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadAccount } from './config.js';
+import { SignUpGeniusClient } from './client.js';
+import { registerUserTools } from './tools/user.js';
+import { registerGroupTools } from './tools/groups.js';
+import { registerSignUpTools } from './tools/signups.js';
+import { registerReportTools } from './tools/reports.js';
+const account = loadAccount();
+const client = new SignUpGeniusClient(account);
+const server = new McpServer({ name: 'signupgenius', version: '1.0.0' });
+registerUserTools(server, client);
+registerGroupTools(server, client);
+registerSignUpTools(server, client);
+registerReportTools(server, client);
+console.error(`[signupgenius-mcp] SignUpGenius: ${account.name} (${account.baseUrl}) [${account.mode}]`);
+console.error('[signupgenius-mcp] Developed and maintained by AI (Claude). Use at your own discretion.');
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/session-login.js

@@ -0,0 +1,126 @@
+/**
+ * Logs in to signupgenius.com with email+password and returns the JWT access
+ * token plus the cookies needed by the legacy SUGboxAPI.cfm dispatcher.
+ *
+ * Flow (reverse-engineered from the public login page):
+ *   1. GET /login — page contains a `csrfToken` hidden input and sets
+ *      cfid/cftoken cookies.
+ *   2. POST /index.cfm?go=c.Login with the form fields the page would submit,
+ *      including the scraped csrfToken. On success the server 302s and sets
+ *      an `accessToken` JWT cookie scoped to .signupgenius.com.
+ *
+ * SSO accounts (Google/Apple/Facebook/Microsoft) and 2FA-enabled accounts are
+ * unsupported — same caveat as canvas-parent-mcp's session mode.
+ */
+const DEFAULT_LOGIN_BASE = 'https://www.signupgenius.com';
+export async function sessionLogin(input) {
+    const base = input.loginUrl ?? DEFAULT_LOGIN_BASE;
+    const jar = new CookieJar();
+    // Step 1: fetch login page, extract csrfToken
+    const loginPage = await fetch(`${base}/login`, {
+        headers: { 'User-Agent': USER_AGENT, Accept: 'text/html' },
+    });
+    if (!loginPage.ok) {
+        throw new LoginFailedError(`login page returned ${loginPage.status}`);
+    }
+    jar.absorb(loginPage.headers);
+    const html = await loginPage.text();
+    const csrfMatch = /name="csrfToken"\s+value="([^"]+)"/.exec(html);
+    if (!csrfMatch) {
+        throw new LoginFailedError('csrfToken not found on login page');
+    }
+    const csrfToken = csrfMatch[1];
+    // Step 2: POST credentials
+    const body = new URLSearchParams({
+        csrfToken,
+        loginemail: input.email,
+        pword: input.password,
+        successpage: 'c.jump&jump=/index.cfm?go=c.MyAccount',
+        failpage: 'c.Register',
+        ScreenWidth: '2000',
+        ScreenHeight: '1200',
+        formaction: '1',
+        formName: 'loginform',
+        refererUrl: '',
+    }).toString();
+    const postRes = await fetch(`${base}/index.cfm?go=c.Login`, {
+        method: 'POST',
+        redirect: 'manual',
+        headers: {
+            'User-Agent': USER_AGENT,
+            Accept: 'text/html',
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Referer: `${base}/login`,
+            Cookie: jar.header(),
+        },
+        body,
+    });
+    jar.absorb(postRes.headers);
+    // A successful login redirects to /index.cfm?go=c.MyAccount. A failed login
+    // 302s to /index.cfm?go=c.Register (the configured failpage) or returns 200
+    // with the login page rerendered. Either way, no accessToken cookie is set.
+    const accessToken = jar.get('accessToken');
+    if (!accessToken) {
+        const location = postRes.headers.get('location') ?? '';
+        const detail = location.includes('c.Register')
+            ? 'login form rejected the credentials'
+            : `login did not yield an accessToken (status ${postRes.status})`;
+        throw new LoginFailedError(detail);
+    }
+    return { accessToken, cookieHeader: jar.header() };
+}
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36';
+/** Minimal Netscape-cookie-style jar — only tracks name/value, no domain matching. */
+class CookieJar {
+    cookies = new Map();
+    absorb(headers) {
+        const setCookies = readSetCookieHeaders(headers);
+        for (const raw of setCookies) {
+            const semi = raw.indexOf(';');
+            const pair = semi >= 0 ? raw.slice(0, semi) : raw;
+            const eq = pair.indexOf('=');
+            if (eq <= 0)
+                continue;
+            const name = pair.slice(0, eq).trim();
+            const value = pair.slice(eq + 1).trim();
+            if (!name)
+                continue;
+            this.cookies.set(name, value);
+        }
+    }
+    get(name) {
+        return this.cookies.get(name);
+    }
+    header() {
+        return Array.from(this.cookies.entries())
+            .map(([k, v]) => `${k}=${v}`)
+            .join('; ');
+    }
+}
+/**
+ * Node's Headers can carry multiple Set-Cookie values; Headers.get joins them
+ * with ", " which breaks parsing because cookie attributes also use commas
+ * (Expires=Wed, 17 Jun 2026 ...). Headers.getSetCookie() is the spec'd way
+ * (Node ≥19, undici ≥5.2) — fall back to the single-string getter for older
+ * runtimes by splitting only on commas that precede a `name=` token.
+ */
+function readSetCookieHeaders(headers) {
+    const anyHeaders = headers;
+    if (typeof anyHeaders.getSetCookie === 'function') {
+        return anyHeaders.getSetCookie();
+    }
+    const raw = headers.get('set-cookie');
+    if (!raw)
+        return [];
+    return raw.split(/,(?=\s*[A-Za-z0-9_-]+=)/);
+}
+export class LoginFailedError extends Error {
+    detail;
+    constructor(detail) {
+        super(`SignUpGenius login failed: ${detail}. ` +
+            'Verify SIGNUPGENIUS_EMAIL / SIGNUPGENIUS_PASSWORD. ' +
+            'SSO accounts (Google/Apple/Facebook/Microsoft) and 2FA-enabled accounts are not supported in session mode.');
+        this.detail = detail;
+        this.name = 'LoginFailedError';
+    }
+}

package/dist/tools/_shared.js

@@ -0,0 +1,4 @@
+/** Wrap a value as an MCP text content block — the standard tool return shape. */
+export function textContent(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}

package/dist/tools/groups.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { textContent } from './_shared.js';
+const listGroupsArgs = z.object({
+    sort: z.enum(['asc', 'desc']).optional().describe('Sort order for group results.'),
+});
+const groupIdArgs = z.object({
+    groupId: z.number().int().positive().describe('Group ID returned by signupgenius_list_groups.'),
+    sort: z.enum(['asc', 'desc']).optional(),
+});
+const memberDetailArgs = z.object({
+    groupId: z.number().int().positive(),
+    memberId: z.number().int().positive().describe('communitymemberid returned by signupgenius_list_group_members.'),
+});
+const addMemberArgs = z.object({
+    groupId: z.number().int().positive(),
+    emailaddress: z.string().email().describe('Email of the member to add to the group.'),
+    firstname: z.string().optional(),
+    lastname: z.string().optional(),
+});
+export function registerGroupTools(server, client) {
+    server.registerTool('signupgenius_list_groups', {
+        description: 'List groups created by the authenticated user. Returns groupid, title, and member count for each group.',
+        annotations: { readOnlyHint: true },
+        inputSchema: listGroupsArgs.shape,
+    }, async (raw) => {
+        const args = listGroupsArgs.parse(raw);
+        const path = client.mode === 'session' ? '/groups/all' : '/groups';
+        const data = await client.request(path, { query: { sort: args.sort } });
+        return textContent(data);
+    });
+    server.registerTool('signupgenius_list_group_members', {
+        description: 'List members of a SignUpGenius group (basic info: name, email, memberid).',
+        annotations: { readOnlyHint: true },
+        inputSchema: groupIdArgs.shape,
+    }, async (raw) => {
+        const args = groupIdArgs.parse(raw);
+        const data = await client.request(`/groups/${args.groupId}/members`, { query: { sort: args.sort } });
+        return textContent(data);
+    });
+    server.registerTool('signupgenius_get_group_member', {
+        description: 'Get detailed info for a group member (address, phone, email) when the member has provided it via a sign-up.',
+        annotations: { readOnlyHint: true },
+        inputSchema: memberDetailArgs.shape,
+    }, async (raw) => {
+        const args = memberDetailArgs.parse(raw);
+        const data = await client.request(`/groups/${args.groupId}/members/${args.memberId}/details`);
+        return textContent(data);
+    });
+    server.registerTool('signupgenius_add_group_member', {
+        description: 'Add a member to a SignUpGenius group by email address. First/last name are optional. ' +
+            'Writes data — confirm with the user before invoking.',
+        annotations: { readOnlyHint: false },
+        inputSchema: addMemberArgs.shape,
+    }, async (raw) => {
+        const args = addMemberArgs.parse(raw);
+        const body = { emailaddress: args.emailaddress };
+        if (args.firstname !== undefined)
+            body.firstname = args.firstname;
+        if (args.lastname !== undefined)
+            body.lastname = args.lastname;
+        const data = await client.request(`/groups/${args.groupId}/members/create`, {
+            method: 'POST',
+            body,
+        });
+        return textContent(data);
+    });
+}

package/dist/tools/reports.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { textContent } from './_shared.js';
+const reportArgs = z.object({
+    signupId: z.number().int().positive().describe('Sign-up ID (signupid).'),
+});
+/**
+ * Report endpoints are Pro-only. The session-mode v3 web API has no
+ * equivalent — only the sign-up owner can pull report data, and the v3 paths
+ * for it were not discovered during recon. We still register the tools so
+ * Claude knows they exist, but in session mode they fail fast with a
+ * ModeMismatchError pointing the user at SIGNUPGENIUS_USER_KEY.
+ */
+export function registerReportTools(server, client) {
+    const register = (toolName, path, blurb) => {
+        server.registerTool(toolName, {
+            description: `${blurb} Requires SIGNUPGENIUS_USER_KEY (Pro subscription) — session mode is not supported for reports.`,
+            annotations: { readOnlyHint: true },
+            inputSchema: reportArgs.shape,
+        }, async (raw) => {
+            client.requireMode('key', toolName);
+            const args = reportArgs.parse(raw);
+            const data = await client.request(`${path}/${args.signupId}`);
+            return textContent(data);
+        });
+    };
+    register('signupgenius_report_all', '/signups/report/all', 'Full report for a sign-up: every slot plus the participant who claimed it (with custom-question answers when present).');
+    register('signupgenius_report_filled', '/signups/report/filled', 'Report for a sign-up restricted to slots that have already been filled.');
+    register('signupgenius_report_available', '/signups/report/available', 'Report for a sign-up restricted to slots that are still open/empty.');
+}

package/dist/tools/signups.js

@@ -0,0 +1,64 @@
+import { textContent } from './_shared.js';
+const LISTINGS = [
+    {
+        name: 'signupgenius_list_created_active',
+        session: '/signups/created',
+        key: '/signups/created/active',
+        desc: {
+            key: 'List ACTIVE sign-ups created by the API key holder.',
+            session: 'List sign-ups created by the authenticated user. In session mode this returns the full list (active + expired) — filter on enddate client-side if you need only active.',
+        },
+    },
+    {
+        name: 'signupgenius_list_created_expired',
+        session: '/signups/created',
+        key: '/signups/created/expired',
+        desc: {
+            key: 'List EXPIRED sign-ups created by the API key holder.',
+            session: 'Alias of signupgenius_list_created_active in session mode (v3 returns active + expired together). Filter on enddate client-side.',
+        },
+    },
+    {
+        name: 'signupgenius_list_created_all',
+        session: '/signups/created',
+        key: '/signups/created/all',
+        desc: {
+            key: 'List ALL sign-ups created by the API key holder (active and expired).',
+            session: 'List ALL sign-ups created by the authenticated user (active and expired).',
+        },
+    },
+    {
+        name: 'signupgenius_list_invited',
+        session: '/signups/invited',
+        key: '/signups/invited/active',
+        desc: {
+            key: 'List sign-ups the user has been invited to. Not applicable to sub-admin credentials.',
+            session: 'List sign-ups the user has been invited to.',
+        },
+    },
+    {
+        name: 'signupgenius_list_signedupfor',
+        session: '/signups/signedupfor',
+        key: '/signups/signedupfor/active',
+        desc: {
+            key: 'List sign-ups the user has personally signed up for. Not applicable to sub-admin credentials.',
+            session: 'List sign-ups the user has personally signed up for.',
+        },
+    },
+];
+export function registerSignUpTools(server, client) {
+    const session = client.mode === 'session';
+    for (const l of LISTINGS) {
+        server.registerTool(l.name, { description: session ? l.desc.session : l.desc.key, annotations: { readOnlyHint: true } }, async () => textContent(await client.request(session ? l.session : l.key)));
+    }
+    // Session-only convenience tool — the legacy CF dispatcher is what the
+    // signupgenius.com wizard itself uses, sometimes with fuller data than v3.
+    if (session) {
+        server.registerTool('signupgenius_legacy_get_my_signups', {
+            description: 'Session mode only. Returns the same sign-up listing the SignUpGenius wizard sees ' +
+                '(via /SUGboxAPI.cfm?go=t.getMySignups). Use when you want fuller data than ' +
+                'signupgenius_list_created_* provides.',
+            annotations: { readOnlyHint: true },
+        }, async () => textContent(await client.request('', { legacyAction: 't.getMySignups' })));
+    }
+}

package/dist/tools/user.js

@@ -0,0 +1,13 @@
+import { textContent } from './_shared.js';
+export function registerUserTools(server, client) {
+    server.registerTool('signupgenius_get_profile', {
+        description: "Get the SignUpGenius profile of the authenticated user (name, email, member ID, " +
+            'subscription level). Useful as a first call to confirm credentials. ' +
+            'Key mode hits /v2/k/user/profile; session mode hits /v3/member/profile.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const path = client.mode === 'session' ? '/member/profile' : '/user/profile';
+        const data = await client.request(path);
+        return textContent(data);
+    });
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "signupgenius-mcp",
+  "version": "1.0.0",
+  "mcpName": "io.github.chrischall/signupgenius-mcp",
+  "description": "SignUpGenius MCP server — read sign-ups, reports, and groups; add group members.",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chrischall/signupgenius-mcp.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "signupgenius",
+    "signups",
+    "volunteers"
+  ],
+  "type": "module",
+  "bin": {
+    "signupgenius-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    "skills",
+    ".mcp.json",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --external:dotenv --outfile=dist/bundle.js",
+    "dev": "node --env-file=.env dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^17.4.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "esbuild": "^0.28.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}