gogcli-mcp 2.26.0 → 2.27.1

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp",
   "display_name": "gogcli",
-  "version": "2.26.0",
+  "version": "2.27.1",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",
@@ -112,6 +112,14 @@
       "name": "gog_gmail_send",
       "description": "Send an email, with attachments from server-side paths (attach) or from base64 bytes sent with the call (attachInline, for remote deployments with no shared filesystem)"
     },
+    {
+      "name": "gog_gmail_reply",
+      "description": "Reply to a Gmail message (sender only), inheriting the \"Re:\" subject and quoting the original below your body"
+    },
+    {
+      "name": "gog_gmail_reply_all",
+      "description": "Reply to every participant of a Gmail message (sender plus all To/Cc), with the same inherited subject and quoted original"
+    },
     {
       "name": "gog_gmail_run",
       "description": "Run any gog gmail subcommand (escape hatch)"

package/mint.yaml

@@ -86,7 +86,7 @@ dependencies:
   # nine pins too.
   - kind: github-release
     repo: openclaw/gogcli
-    tag: v0.38.1
+    tag: v0.38.3
     asset: "gogcli_*_linux_amd64.tar.gz"
     bin: [gog]
 state:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp",
-  "version": "2.26.0",
+  "version": "2.27.1",
   "mcpName": "io.github.chrischall/gogcli-mcp",
   "description": "MCP server wrapping gogcli for Google service access",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -41,12 +41,12 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^0.15.0",
+    "@chrischall/mcp-utils": "^0.17.1",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.0",
     "@vitest/coverage-v8": "^4.1.8",
     "esbuild": "^0.28.2",
     "typescript": "^7.0.2",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp"
   },
-  "version": "2.26.0",
+  "version": "2.27.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp",
-      "version": "2.26.0",
+      "version": "2.27.1",
       "transport": {
         "type": "stdio"
       },

package/src/lib.ts

@@ -16,6 +16,11 @@ export {
   registerSlidesTools,
   registerTasksTools,
 } from './server.js';
+// The reply/reply-all schema and flag builder live in the base package so the
+// gmail sub-package's draft-side twins reuse ONE definition — registering the
+// same tool name from both registrar lists would be a duplicate-name error.
+export { replySchema, appendReplyFlags } from './tools/gmail.js';
+export type { ReplyFlags } from './tools/gmail.js';
 export { run, runBinary, runExecutor, isGogFileArg, MIN_GOG_VERSION } from './runner.js';
 // Sub-package tools that read gog JSON through bare `run()` (rather than the
 // `runOrDiagnose` seam) must still apply this, or their timestamps skip the
@@ -57,4 +62,5 @@ export {
   pageAliasParam,
   resolvePageToken,
   registerRunTool,
+  assertNotBoth,
 } from './tools/utils.js';

package/src/runner.ts

@@ -217,7 +217,7 @@ const TIMEOUT_MS = 30_000;
 // so the requirement change is surfaced in the release notes (see
 // .github/release.yml). This is the single source of truth for the required
 // version; keep the README/CLAUDE.md mention in sync.
-export const MIN_GOG_VERSION = '0.38.1';
+export const MIN_GOG_VERSION = '0.38.3';
 
 // Interpret the GOG_READONLY kill-switch. `readEnvVar` already treats blank
 // values, 'undefined'/'null' sentinels, and unresolved .mcpb placeholders

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.26.0'; // x-release-please-version
+const VERSION = '2.27.1'; // 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/server.test.ts

@@ -43,3 +43,68 @@ 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.
+    // Only labels whose normalised form differs from their tool prefix belong
+    // here. "Apps Script" normalises to `appsscript` but the tools are
+    // `gog_appscript_`, so that mapping is load-bearing. A `discoveryapi` entry
+    // was not: both tables label the row "API", which normalises to `api` and
+    // already resolves — so it never matched and only implied a label that
+    // does not exist.
+    const prefixFor: Record<string, string> = {
+      appsscript: 'appscript',
+    };
+    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);
+    }
+  });
+});