gogcli-mcp 2.25.0 → 2.27.0

package/src/tools/chat.ts

@@ -0,0 +1,253 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+  accountParam,
+  runOrDiagnose,
+  registerRunTool,
+  paginationParams,
+  pushPaginationFlags,
+} from './utils.js';
+import type { GogArg } from '../runner.js';
+import { attachInlineParam, inlineAttachmentArgs } from '../attachments.js';
+
+// Google Chat (gog >= 0.38.0 for the mention/reaction metadata in
+// `messages list`; the rest of the surface is older).
+//
+// TWO NAMING SYSTEMS MEET HERE, and mixing them is the mistake this module's
+// descriptions exist to prevent. Chat identifies everything by RESOURCE NAME —
+// `spaces/AAAA`, `spaces/AAAA/messages/BBBB`, `spaces/AAAA/threads/CCCC` — and
+// those names are what every tool below wants. A bare ID (`BBBB`) is accepted
+// for a message only when `space` says which space it lives in, which is why
+// the reaction tools carry that extra parameter.
+//
+// gog_chat_spaces_find / gog_chat_dm_space are the bridges from human words
+// ("the launch room", "alice@example.com") to those names; reach for one of
+// them first rather than guessing a resource name.
+//
+// WORKSPACE-ONLY, AND THAT IS NOT A SCOPE PROBLEM: gog refuses every chat call
+// on a consumer @gmail.com account with "chat requires a Google Workspace
+// account (non-gmail.com)" — verified live against gog 0.38.0 — no matter which
+// scopes the token carries. Re-authorizing cannot fix it, so the note below is
+// appended to every description here: a model that reads "permission error" as
+// "missing scope" would otherwise burn a re-auth round trip on an account that
+// can never work.
+export function registerChatTools(server: McpServer): void {
+  const workspaceOnlyNote =
+    ' WORKSPACE ONLY: Google Chat has no API for consumer accounts, so this fails on an @gmail.com '
+    + 'account with "chat requires a Google Workspace account". That is the ACCOUNT, not the token — '
+    + 're-authorizing or adding scopes will not help.';
+  const spaceParam = z.string().describe(
+    'Space resource name, e.g. "spaces/AAAAsomeID" (from gog_chat_spaces_list, gog_chat_spaces_find or gog_chat_dm_space)',
+  );
+  const threadParam = z.string().optional().describe(
+    'Thread resource name, e.g. "spaces/AAAA/threads/CCCC" — reply inside that thread instead of starting a new one',
+  );
+
+  server.registerTool('gog_chat_spaces_list', {
+    description:
+      'List the Google Chat spaces the account belongs to — named rooms and DMs alike — with their resource names. '
+      + 'Start here when you do not yet have a space name; gog_chat_spaces_find is faster when you know the room\'s title.'
+      + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ max, pageToken, page, all, account }) => {
+    const args = ['chat', 'spaces', 'list'];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_spaces_find', {
+    description:
+      'Find spaces whose display name matches. Substring and case-insensitive by default, which is what you want when the '
+      + 'user names a room approximately ("the launch room"); pass exact=true to require the whole title. DMs have no '
+      + 'display name — use gog_chat_dm_space to reach a person.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      displayName: z.string().describe('Space display name, or part of one'),
+      exact: z.boolean().optional().describe('Require an exact (still case-insensitive) match on the whole display name'),
+      max: z.number().int().optional().describe('Max results per page'),
+      account: accountParam,
+    },
+  }, async ({ displayName, exact, max, account }) => {
+    const args = ['chat', 'spaces', 'find', displayName];
+    if (exact) args.push('--exact');
+    if (max !== undefined) args.push(`--max=${max}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_spaces_create', {
+    description:
+      'Create a named Chat space, optionally seeding its membership. Members are added immediately and are notified — this '
+      + 'is visible to other people the moment it runs, so confirm the member list before calling it.' + workspaceOnlyNote,
+    inputSchema: {
+      displayName: z.string().describe('Display name for the new space'),
+      members: z.array(z.string()).optional().describe('Initial members, as email addresses or "users/..." resource names'),
+      account: accountParam,
+    },
+  }, async ({ displayName, members, account }) => {
+    const args = ['chat', 'spaces', 'create', displayName];
+    if (members) for (const member of members) args.push(`--member=${member}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_threads_list', {
+    description:
+      'List the threads in a space, so a reply can be targeted at an existing conversation rather than starting a new one. '
+      + 'Pass a thread name from here as `thread` to gog_chat_messages_send.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      space: spaceParam,
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ space, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'threads', 'list', space];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_messages_list', {
+    description:
+      'Read messages in a space. The JSON carries each message\'s @-mentions and a summary of its emoji reactions '
+      + '(gog >= 0.38.0) alongside the text, so "who was tagged" and "did anyone react" are answerable without extra calls. '
+      + 'unread=true returns only what arrived after the account last read the space — the cheap way to answer "what did I '
+      + 'miss". Newest-first needs an explicit order="createTime desc"; Chat\'s own default is oldest-first.'
+      + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      space: spaceParam,
+      thread: threadParam,
+      unread: z.boolean().optional().describe('Only messages posted after the account last read this space'),
+      order: z.enum(['createTime asc', 'createTime desc', 'lastUpdateTime asc', 'lastUpdateTime desc'])
+        .optional().describe('Sort order (Chat default: "createTime asc", i.e. OLDEST first — ask for "createTime desc" when you want the latest messages)'),
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ space, thread, unread, order, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'messages', 'list', space];
+    if (thread) args.push(`--thread=${thread}`);
+    if (unread) args.push('--unread');
+    if (order) args.push(`--order=${order}`);
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_messages_send', {
+    description:
+      'Post a message to a Chat space. THIS IS IMMEDIATELY VISIBLE TO EVERYONE IN THE SPACE and cannot be unsent through '
+      + 'this tool, so treat it like sending mail, not like saving a draft. Pass `thread` to reply inside an existing '
+      + 'conversation (from gog_chat_threads_list or a message\'s thread field); omit it to start a new one. Text supports '
+      + 'Chat\'s markdown-ish formatting (*bold*, _italic_, `code`).' + workspaceOnlyNote,
+    inputSchema: {
+      space: spaceParam,
+      text: z.string().optional().describe('Message text. Optional only when an attachment is supplied.'),
+      thread: threadParam,
+      attach: z.array(z.string()).optional().describe(
+        'Attachment file paths, read WHERE GOG RUNS. On a hosted or remote deployment that is not your machine — use '
+        + 'attachInline there instead.',
+      ),
+      attachInline: attachInlineParam,
+      account: accountParam,
+    },
+  }, async ({ space, text, thread, attach, attachInline, account }) => {
+    if (text === undefined && !attach?.length && !attachInline?.length) {
+      throw new Error('A Chat message needs text, an attachment, or both.');
+    }
+    const args: GogArg[] = ['chat', 'messages', 'send', space];
+    if (text !== undefined) args.push(`--text=${text}`);
+    if (thread) args.push(`--thread=${thread}`);
+    if (attach) for (const path of attach) args.push(`--attach=${path}`);
+    // Same repeatable --attach flag; the executor materializes each payload to
+    // a temp file beside gog. `args` is passed so the size check sees the whole
+    // request, not just the attachments.
+    args.push(...inlineAttachmentArgs('attach', attachInline, args));
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_dm_send', {
+    description:
+      'Send a direct message to one person by email address, creating the DM space if this is the first message. Delivered '
+      + 'immediately and cannot be unsent through this tool. For a room rather than a person, use gog_chat_messages_send.'
+      + workspaceOnlyNote,
+    inputSchema: {
+      email: z.string().describe('Recipient email address'),
+      text: z.string().describe('Message text'),
+      thread: threadParam,
+      account: accountParam,
+    },
+  }, async ({ email, text, thread, account }) => {
+    const args = ['chat', 'dm', 'send', email, `--text=${text}`];
+    if (thread) args.push(`--thread=${thread}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_dm_space', {
+    description:
+      'Resolve the DM space for an email address — the bridge from a person to the "spaces/..." name the message tools '
+      + 'want. Creates the space if none exists yet, which is silent: it does not message the person.' + workspaceOnlyNote,
+    inputSchema: {
+      email: z.string().describe('The other person\'s email address'),
+      account: accountParam,
+    },
+  }, async ({ email, account }) => {
+    return runOrDiagnose(['chat', 'dm', 'space', email], { account });
+  });
+
+  server.registerTool('gog_chat_reactions_list', {
+    description:
+      'List the emoji reactions on one message, with who reacted. gog_chat_messages_list already returns a reaction '
+      + 'SUMMARY per message; come here when you need the individual reactors, or the reaction resource names that '
+      + 'gog_chat_reactions_delete takes.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
+      space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ message, space, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'messages', 'reactions', 'list', message];
+    if (space) args.push(`--space=${space}`);
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_reactions_create', {
+    description:
+      'React to a message with an emoji. Visible to the space immediately. Pass the emoji itself ("👍"), not a :shortcode:.'
+      + workspaceOnlyNote,
+    inputSchema: {
+      message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
+      emoji: z.string().describe('The emoji character to react with, e.g. "👍"'),
+      space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
+      account: accountParam,
+    },
+  }, async ({ message, emoji, space, account }) => {
+    const args = ['chat', 'messages', 'reactions', 'create', message, emoji];
+    if (space) args.push(`--space=${space}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_reactions_delete', {
+    description:
+      'Remove one emoji reaction. Takes the REACTION\'s own resource name ("spaces/.../messages/.../reactions/..."), not '
+      + 'the message\'s and not the emoji — get it from gog_chat_reactions_list. An account can only remove its own reaction.'
+      + workspaceOnlyNote,
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      reaction: z.string().describe('Reaction resource name, e.g. "spaces/AAAA/messages/BBBB/reactions/CCCC"'),
+      account: accountParam,
+    },
+  }, async ({ reaction, account }) => {
+    return runOrDiagnose(['chat', 'messages', 'reactions', 'delete', reaction], { account });
+  });
+
+  registerRunTool(server, {
+    service: 'chat',
+    examples: '"spaces", "messages", "dm"',
+    note: 'Google Chat has no API for consumer accounts: every chat subcommand fails on an @gmail.com account regardless of scopes.',
+  });
+}

package/src/tools/gmail.ts

@@ -1,9 +1,86 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, registerRunTool, payloadArg, pageTokenParam, pageAliasParam, resolvePageToken } from './utils.js';
+import { accountParam, runOrDiagnose, registerRunTool, payloadArg, pageTokenParam, pageAliasParam, resolvePageToken, assertNotBoth } from './utils.js';
 import { finalizeGmailSearch, fetchGmailPages } from '../gmail-results.js';
 import type { GogArg } from '../runner.js';
 import { attachInlineParam, inlineAttachmentArgs } from '../attachments.js';
+import type { InlineAttachmentInput } from '../attachments.js';
+
+// gmail reply / reply-all share an identical flag set (gog 0.27+); they differ
+// only in the subcommand and default recipient set (reply → sender; reply-all
+// → every participant). Recipient flags are repeatable on the CLI, so they are
+// arrays here. --to/--cc/--bcc ADD or MOVE recipients onto the inherited reply
+// set; --remove drops them. Body/HTML follow the same inline-or-file shape as
+// the draft tools.
+export const replySchema = {
+  messageId: z.string().describe('Gmail message ID to reply to — the short hex `id` from gog_gmail_get / _search (or gog_gmail_messages_search, gogcli-mcp-gmail only). NOT the threadId, NOT the RFC822 `<…@host>` Message-Id header.'),
+  body: z.string().optional().describe('Reply body (plain text; required unless bodyHtml or bodyHtmlFile is set). Any size — a large body is written to a temp file on the gog server rather than inlined into the command line. Note gog strips trailing newlines from a file-delivered body.'),
+  bodyHtml: z.string().optional().describe('Reply body (HTML; optional). Pass the HTML itself at any size — a large body is written to a temp file on the gog server rather than inlined into the command line. Mutually exclusive with bodyHtmlFile.'),
+  bodyHtmlFile: z.string().optional().describe('Path to an HTML file that ALREADY EXISTS on the gog server for the reply body. gog also accepts "-" for stdin, but this server never writes to gog\'s stdin, so "-" would hang until the call times out. Mutually exclusive with bodyHtml — supplying both is rejected. You rarely need this: bodyHtml handles large bodies on its own.'),
+  to: z.array(z.string()).optional().describe('Add or move recipients to To (repeatable). Added on top of the recipients inherited from the original message.'),
+  cc: z.array(z.string()).optional().describe('Add or move recipients to Cc (repeatable)'),
+  bcc: z.array(z.string()).optional().describe('Add or move recipients to Bcc (repeatable)'),
+  remove: z.array(z.string()).optional().describe('Remove these recipients from all fields (repeatable) — e.g. to drop someone from a reply-all.'),
+  subject: z.string().optional().describe('Override reply subject (default: "Re: <original>"). A changed subject starts a NEW Gmail thread.'),
+  noQuote: z.boolean().optional().describe('Do not include the original message quoted below the reply (default: the original is quoted)'),
+  attach: z.array(z.string()).optional().describe('File paths to attach (repeatable), resolved ON THE GOG SERVER\'s filesystem — NOT this client\'s. Only usable when gog runs on the same machine you do (local stdio); on the hosted connector or any GOG_RUNNER_URL backend these paths do not exist and the call fails with "no such file or directory" — use attachInline there. Read on the server, base64-encoded with a MIME type inferred from the extension.'),
+  attachInline: attachInlineParam,
+  from: z.string().optional().describe('Send from this email address (must be a verified send-as alias)'),
+  autoFromAddressedAlias: z.boolean().optional().describe('When from is omitted, send from the verified send-as alias the original message was addressed TO, instead of the account\'s primary address — so a reply to mail sent to an alias goes back out from that alias. Ignored when from is set.'),
+  signature: z.boolean().optional().describe('Append the Gmail signature from the active send-as address'),
+  signatureFrom: z.string().optional().describe('Append the Gmail signature from this send-as email address'),
+  signatureFile: z.string().optional().describe('Append a local signature file (plain text or HTML), read on the gog server'),
+  account: accountParam,
+};
+
+export type ReplyFlags = {
+  body?: string;
+  bodyHtml?: string;
+  bodyHtmlFile?: string;
+  to?: string[];
+  cc?: string[];
+  bcc?: string[];
+  remove?: string[];
+  subject?: string;
+  noQuote?: boolean;
+  attach?: string[];
+  attachInline?: InlineAttachmentInput[];
+  from?: string;
+  autoFromAddressedAlias?: boolean;
+  signature?: boolean;
+  signatureFrom?: string;
+  signatureFile?: string;
+};
+
+export function appendReplyFlags(args: GogArg[], f: ReplyFlags): void {
+  assertNotBoth('bodyHtml', 'bodyHtmlFile', f.bodyHtml, f.bodyHtmlFile);
+  if (f.body) args.push(payloadArg('body', 'body-file', f.body));
+  if (f.bodyHtml) args.push(payloadArg('body-html', 'body-html-file', f.bodyHtml, 'html'));
+  else if (f.bodyHtmlFile) args.push(`--body-html-file=${f.bodyHtmlFile}`);
+  if (f.to) for (const r of f.to) args.push(`--to=${r}`);
+  if (f.cc) for (const r of f.cc) args.push(`--cc=${r}`);
+  if (f.bcc) for (const r of f.bcc) args.push(`--bcc=${r}`);
+  if (f.remove) for (const r of f.remove) args.push(`--remove=${r}`);
+  if (f.subject) args.push(`--subject=${f.subject}`);
+  if (f.noQuote) args.push('--no-quote');
+  if (f.attach) for (const p of f.attach) args.push(`--attach=${p}`);
+  // Same repeatable --attach flag, but the bytes travel with the call: the
+  // executor writes each one to a temp file beside gog and passes that path.
+  // This is the only attachment route that works when the caller and gog do not
+  // share a filesystem (hosted connector, GOG_RUNNER_URL backend). `args` is
+  // passed so the size check sees the body too, which shares the same budget
+  // once payloadArg has turned it into a file arg.
+  args.push(...inlineAttachmentArgs('attach', f.attachInline, args));
+  if (f.from) args.push(`--from=${f.from}`);
+  if (f.signature) args.push('--signature');
+  if (f.signatureFrom) args.push(`--signature-from=${f.signatureFrom}`);
+  if (f.signatureFile) args.push(`--signature-file=${f.signatureFile}`);
+  // PINNED, not conditional: GOG_GMAIL_AUTO_FROM_ADDRESSED_ALIAS in the host env
+  // silently changes which address the mail goes out FROM, with nothing in the arg
+  // array to show for it — and the remote runner's backend env is not ours to set.
+  // An explicit flag is the only value authoritative on both transports.
+  args.push(f.autoFromAddressedAlias ? '--auto-from-addressed-alias' : '--auto-from-addressed-alias=false');
+}
 
 export function registerGmailTools(server: McpServer): void {
   server.registerTool('gog_gmail_search', {
@@ -73,7 +150,10 @@ export function registerGmailTools(server: McpServer): void {
       + 'the same machine gog runs on — on the hosted connector and any remote deployment there is no '
       + 'shared filesystem, so no path you can name resolves there and `attach` will fail with '
       + '"no such file or directory". When either is used, the JSON result echoes the attached filenames '
-      + 'and byte sizes — check it to confirm the files were embedded.',
+      + 'and byte sizes — check it to confirm the files were embedded. '
+      + 'NOT the tool for answering a message: replyToMessageId only files this in the right thread — the '
+      + 'subject, recipients and body are entirely yours, and the original is not quoted unless you set '
+      + 'quote. Use gog_gmail_reply / gog_gmail_reply_all instead, which inherit all three.',
     annotations: { destructiveHint: true },
     inputSchema: {
       to: z.string().describe('Recipient(s), comma-separated'),
@@ -81,13 +161,14 @@ export function registerGmailTools(server: McpServer): void {
       body: z.string().describe('Email body (plain text). Any size — a large body is written to a temp file on the gog server rather than inlined into the command line. Note gog strips trailing newlines from a file-delivered body.'),
       cc: z.string().optional().describe('CC recipients, comma-separated'),
       bcc: z.string().optional().describe('BCC recipients, comma-separated'),
-      replyToMessageId: z.string().optional().describe('Message ID to reply to'),
-      threadId: z.string().optional().describe('Thread ID to reply within'),
+      replyToMessageId: z.string().optional().describe('Message ID to thread this message against — sets In-Reply-To/References only. It does NOT quote the original (pass quote for that), inherit its recipients, or prefix the subject with "Re:". For an actual reply use gog_gmail_reply.'),
+      threadId: z.string().optional().describe('Thread ID to thread this message within. Same caveat as replyToMessageId: threading only, no quote and no inherited subject or recipients.'),
+      quote: z.boolean().optional().describe('Include the original message quoted below the body. Requires replyToMessageId or threadId. gog quotes by DEFAULT on gmail reply but never on gmail send, so without this a threaded send arrives with the original nowhere in it.'),
       attach: z.array(z.string()).optional().describe('File paths to attach (repeatable), resolved ON THE GOG SERVER\'s filesystem — NOT this client\'s. Only usable when gog runs on the same machine you do (local stdio); on the hosted connector or any GOG_RUNNER_URL backend these paths do not exist and the call fails with "no such file or directory" — use attachInline there. Each file is read on the server, base64-encoded with a MIME type inferred from its extension, and added as a multipart attachment.'),
       attachInline: attachInlineParam,
       account: accountParam,
     },
-  }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, attach, attachInline, account }) => {
+  }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, quote, attach, attachInline, account }) => {
     // A long body cannot ride in argv: the hosted runner caps a single arg and
     // Linux caps MAX_ARG_STRLEN at 128 KiB. payloadArg swaps it for --body-file
     // past the shared threshold; the executor materializes the temp file.
@@ -96,6 +177,10 @@ export function registerGmailTools(server: McpServer): void {
     if (bcc) args.push(`--bcc=${bcc}`);
     if (replyToMessageId) args.push(`--reply-to-message-id=${replyToMessageId}`);
     if (threadId) args.push(`--thread-id=${threadId}`);
+    // gog's --quote on `gmail send` is opt-in (a plain bool defaulting false),
+    // the mirror image of `gmail reply`, where quoting is the default and
+    // --no-quote opts out. Nothing here can be inferred from the reply target.
+    if (quote) args.push('--quote');
     if (attach) for (const path of attach) args.push(`--attach=${path}`);
     // Same repeatable --attach flag; the executor materializes each payload to a
     // temp file beside gog and substitutes its path. `args` is passed so the
@@ -106,5 +191,51 @@ export function registerGmailTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
+  // ==========================================================================
+  // REPLY / REPLY-ALL
+  //
+  // These live here, in the base package, because gog_gmail_send +
+  // replyToMessageId is NOT a reply. It sets In-Reply-To/References — so Gmail
+  // files it in the right thread — and stops there: no quoted original, no
+  // inherited "Re:" subject, no inherited recipients. To anyone reading the
+  // body it arrives as a brand-new message.
+  //
+  // The asymmetry is gog's: `gmail reply` quotes BY DEFAULT (opt out with
+  // --no-quote), while `gmail send` quotes only on an explicit --quote
+  // (internal/cmd/gmail_send.go, a plain bool defaulting false). The gmail
+  // sub-package reuses replySchema/appendReplyFlags for its draft-side twins
+  // rather than declaring a second copy — registering these tools twice in the
+  // one server would be a duplicate-name error.
+  // ==========================================================================
+  server.registerTool('gog_gmail_reply', {
+    description:
+      'Reply to a Gmail message (goes to the original sender only). USE THIS, not gog_gmail_send, whenever you are '
+      + 'answering a message: it threads off the original AND inherits its "Re:" subject and quotes its body below '
+      + 'yours, which gog_gmail_send does not — a send with replyToMessageId lands in the right thread but reads as a '
+      + 'brand-new message, with the original nowhere in it. To answer every participant use gog_gmail_reply_all. '
+      + 'The gogcli-mcp-gmail package adds two more routes with the same composition: gog_gmail_autoreply to reply '
+      + 'across every message matching a query, and gog_gmail_drafts_reply to stage this exact reply as a draft '
+      + 'instead of sending it.',
+    annotations: { destructiveHint: true },
+    inputSchema: replySchema,
+  }, async ({ messageId, account, ...flags }) => {
+    const args: GogArg[] = ['gmail', 'reply', messageId];
+    appendReplyFlags(args, flags);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_reply_all', {
+    description:
+      'Reply to all participants of a Gmail message (the sender plus every To/Cc recipient). Same inherited "Re:" '
+      + 'subject and quoted original as gog_gmail_reply. Use the remove flag to drop specific recipients from the '
+      + 'reply-all. To stage it as a draft rather than send it, use gog_gmail_drafts_reply_all (gogcli-mcp-gmail only).',
+    annotations: { destructiveHint: true },
+    inputSchema: replySchema,
+  }, async ({ messageId, account, ...flags }) => {
+    const args: GogArg[] = ['gmail', 'reply-all', messageId];
+    appendReplyFlags(args, flags);
+    return runOrDiagnose(args, { account });
+  });
+
   registerRunTool(server, { service: 'gmail', examples: '"archive", "mark-read", "labels"' });
 }

package/src/tools/utils.ts

@@ -441,3 +441,23 @@ export function formatAuthHealth(raw: string, now: number): string {
   }
   return accounts.map((a) => formatOneAccountHealth(a, now)).join('\n\n');
 }
+
+// gog rejects an inline flag together with its --*-file twin — `gmail drafts
+// create` errors with "use only one of --body-html or --body-html-file", and
+// `gmail forward` does the same for --note (misreporting it as --body). Catch
+// the conflict here so the caller gets a message naming the TOOL params it
+// actually passed, instead of a gog error naming flags it never saw.
+export function assertNotBoth(
+  inlineParam: string,
+  fileParam: string,
+  inlineValue: string | undefined,
+  fileValue: string | undefined,
+): void {
+  if (inlineValue !== undefined && fileValue !== undefined) {
+    throw new Error(
+      `${inlineParam} and ${fileParam} are mutually exclusive — gog accepts only one of them. ` +
+      `Pass ${inlineParam} with the content itself (it is written to a temp file automatically when large), ` +
+      `or ${fileParam} with a path that already exists on the gog server.`,
+    );
+  }
+}

package/src/worker.ts

@@ -38,7 +38,7 @@ import { gogAuth, CONNECTOR_INSTRUCTIONS, type GogProps } from './connector-auth
 // connector with all ~360 tools at once. Add whichever paths you want as separate
 // connectors in claude.ai (each authorizes with the same connector key).
 
-const VERSION = '2.25.0'; // x-release-please-version
+const VERSION = '2.27.0'; // x-release-please-version
 
 // Build an McpAgent subclass whose init() registers `registrars` onto its server,
 // each handler wrapped in the ALS scope carrying the per-session Fly executor.

package/tests/gmail-results.test.ts

@@ -255,6 +255,53 @@ describe('fetchGmailPages', () => {
     expect(runPage).toHaveBeenCalledTimes(2);
   });
 
+  // A REPEATED CURSOR IS A STALL, and gog 0.38.0 fixed the same class on its own
+  // side (openclaw/gogcli#1004) — but that fix covers gog's `--all`, and this
+  // walk is our own: it makes N separate single-page gog calls, so a cursor
+  // Google repeats comes straight back to this loop. Without a guard the walk
+  // re-fetches the same page and merges its items again on every remaining
+  // iteration, so the caller gets DUPLICATES presented as more results, which is
+  // worse than a short answer because nothing about the payload looks wrong.
+  it('stops when Google repeats a cursor, instead of re-fetching the same page', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a', 'b']);
+    // Stopped after the repeat was seen — NOT after burning all 10 pages.
+    expect(runPage).toHaveBeenCalledTimes(2);
+  });
+
+  it('still reads as truncated after a repeated cursor', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    // The walk could not reach the end, so the cursor STAYS. Dropping it would
+    // claim completeness we never established, and a set that reads complete is
+    // exactly how "that email doesn't exist" gets reported about mail that does.
+    expect(out.nextPageToken).toBe('T1');
+  });
+
+  it('detects a cursor that repeats the caller-supplied one', async () => {
+    const runPage = vi.fn().mockResolvedValueOnce(page(['a'], 'START'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, 'START')).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a']);
+    expect(out.nextPageToken).toBe('START');
+    expect(runPage).toHaveBeenCalledTimes(1);
+  });
+
+  it('detects a cursor that repeats a token from earlier in the walk, not just the previous one', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T2'))
+      .mockResolvedValueOnce(page(['c'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a', 'b', 'c']);
+    expect(out.nextPageToken).toBe('T1');
+    expect(runPage).toHaveBeenCalledTimes(3);
+  });
+
   it('starts from a caller-supplied cursor', async () => {
     const runPage = vi.fn().mockResolvedValue(page(['a']));
     await fetchGmailPages(runPage, 'threads', 3, 'START');

package/tests/server.test.ts

@@ -14,8 +14,10 @@ describe('BASE_TOOL_REGISTRARS', () => {
     // One representative tool per service registrar, in registrar order.
     for (const expected of [
       'gog_api_list',
+      'gog_appscript_get',
       'gog_auth_list',
       'gog_calendar_events',
+      'gog_chat_spaces_list',
       'gog_classroom_courses_list',
       'gog_contacts_list',
       'gog_docs_cat',
@@ -41,3 +43,62 @@ describe('VERSION', () => {
     expect(VERSION).toBe('0.0.0');
   });
 });
+
+// The tool counts in README.md, SKILL.md and manifest.json are hand-maintained
+// and have now drifted twice (0ec3470 "correct the stale tool counts", then
+// again when reply/reply-all landed). They are the first thing a reader sees,
+// so derive the truth from the registrars and fail the build on a mismatch
+// rather than catching it in review a release later.
+describe('published tool counts match the registrars', () => {
+  const readPkgFile = async (name: string) => {
+    const { readFile } = await import('node:fs/promises');
+    const { fileURLToPath } = await import('node:url');
+    return readFile(fileURLToPath(new URL(`../${name}`, import.meta.url)), 'utf8');
+  };
+
+  const liveToolNames = async (): Promise<string[]> => {
+    const harness = await createTestHarness((server) => {
+      for (const register of BASE_TOOL_REGISTRARS) register(server, undefined);
+    });
+    const names = (await harness.listTools()).map((t) => t.name);
+    await harness.close();
+    return names;
+  };
+
+  it('manifest.json lists exactly the registered tools', async () => {
+    const names = await liveToolNames();
+    const manifest = JSON.parse(await readPkgFile('manifest.json')) as { tools: Array<{ name: string }> };
+    expect([...manifest.tools.map((t) => t.name)].sort()).toEqual([...names].sort());
+  });
+
+  it.each(['README.md', 'SKILL.md'])('%s states the real total', async (file) => {
+    const total = (await liveToolNames()).length;
+    const text = await readPkgFile(file);
+    const heading = /^## Tools \((\d+)\)$/m.exec(text);
+    expect(heading, `${file} has no "## Tools (N)" heading`).not.toBeNull();
+    expect(Number(heading![1])).toBe(total);
+    // README also states the count in its opening paragraph.
+    const prose = /Includes (\d+) tools across/.exec(text);
+    if (prose) expect(Number(prose[1])).toBe(total);
+  });
+
+  it.each(['README.md', 'SKILL.md'])('%s states the real per-service counts', async (file) => {
+    const names = await liveToolNames();
+    const text = await readPkgFile(file);
+    // README: `| **Gmail** | 6 | …`   SKILL: `| **Gmail** (6) | …`
+    const rows = [...text.matchAll(/^\| \*\*(.+?)\*\*(?: \((\d+)\)| \| (\d+))? \|/gm)];
+    expect(rows.length).toBeGreaterThan(0);
+    const service = (row: string) => row.toLowerCase().replace(/[^a-z]/g, '');
+    // Map a table label onto the gog_<service>_ prefix its tools carry.
+    const prefixFor: Record<string, string> = {
+      appsscript: 'appscript', discoveryapi: 'api',
+    };
+    for (const row of rows) {
+      const stated = Number(row[2] ?? row[3]);
+      if (!Number.isFinite(stated)) continue;
+      const key = service(row[1]);
+      const prefix = `gog_${prefixFor[key] ?? key}_`;
+      expect(names.filter((n) => n.startsWith(prefix)).length, `${file} row ${row[1]}`).toBe(stated);
+    }
+  });
+});