gogcli-mcp-gmail 2.23.2 → 2.24.0

package/README.md

@@ -3,7 +3,7 @@
 > [!WARNING]
 > **AI-developed project.** This codebase was built and is actively maintained by [Claude Code](https://www.anthropic.com/claude). Review all code and tool permissions before use.
 
-Extended Gmail [MCP](https://modelcontextprotocol.io) server via [gogcli](https://github.com/openclaw/gogcli). Includes auth tools plus 46 additional dedicated Gmail tools for threads, labels, drafts, attachments, forwarding, autoreply, and bulk operations.
+Extended Gmail [MCP](https://modelcontextprotocol.io) server via [gogcli](https://github.com/openclaw/gogcli). Includes auth tools plus 49 additional dedicated Gmail tools for threads, labels, drafts, attachments, forwarding, autoreply, and bulk operations.
 
 ## Requirements
 
@@ -44,9 +44,9 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 claude mcp add gogcli-gmail -- gogcli-mcp-gmail
 ```
 
-## Extra Gmail Tools (46)
+## Extra Gmail Tools (49)
 
-Plus 8 auth tools and 4 base Gmail tools (search, get, send, run) — 58 in all.
+Plus 8 auth tools and 4 base Gmail tools (search, get, send, run) — 61 in all.
 
 ### Read
 
@@ -101,6 +101,9 @@ Plus 8 auth tools and 4 base Gmail tools (search, get, send, run) — 58 in all.
 | `gog_gmail_drafts_delete` | Delete a draft |
 | `gog_gmail_drafts_send` | Send an existing draft (a 404 comes back diagnosed — `DRAFT_FORKED`, or `GOOGLE_404_NOT_THE_DRAFT` when the draft is still listed) |
 | `gog_gmail_drafts_diff` | Diff two named drafts — divergent body lines (with untruncated `onlyInACount`/`onlyInBCount`), threading loss, and a conservative fork verdict (2 gog calls) |
+| `gog_gmail_drafts_reply` | Save a reply as a draft — inherited recipients, subject and quote; never sends |
+| `gog_gmail_drafts_reply_all` | Save a reply-all as a draft; never sends |
+| `gog_gmail_drafts_forward` | Save a forward as a draft; recipients optional, so it can be staged without any |
 
 #### When a draft you created stops resolving
 

package/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user asks to read, organize, draft, forward, autoreply
 
 # gogcli-mcp-gmail
 
-Extended Gmail MCP server via [gogcli](https://github.com/openclaw/gogcli) — 58 tools: 8 auth + 4 base Gmail + 46 extra dedicated Gmail tools.
+Extended Gmail MCP server via [gogcli](https://github.com/openclaw/gogcli) — 61 tools: 8 auth + 4 base Gmail + 49 extra dedicated Gmail tools.
 
 - **Source:** [github.com/chrischall/gogcli-mcp](https://github.com/chrischall/gogcli-mcp)
 
@@ -80,6 +80,9 @@ Extended Gmail MCP server via [gogcli](https://github.com/openclaw/gogcli) — 5
 | `gog_gmail_drafts_delete` | Delete a draft |
 | `gog_gmail_drafts_send` | Send a draft (404 → `DRAFT_FORKED`, or `GOOGLE_404_NOT_THE_DRAFT` if the draft is still listed) |
 | `gog_gmail_drafts_diff` | Diff two drafts (body divergence, threading loss, fork verdict) |
+| `gog_gmail_drafts_reply` | Save a reply as a draft — inherited recipients, subject and quote; never sends |
+| `gog_gmail_drafts_reply_all` | Save a reply-all as a draft; never sends |
+| `gog_gmail_drafts_forward` | Save a forward as a draft; recipients optional, so it can be staged without any |
 
 A draft edited in a mail client is replaced, not updated: the old id 404s. `drafts_update` / `drafts_send` answer that
 404 with a `DRAFT_FORKED` report (what happened, the drafts that exist, what to do) instead of a bare `notFound`, at a

package/dist/index.js

@@ -31753,6 +31753,7 @@ function formatAuthHealth(raw, now) {
 // ../gogcli-mcp/src/tools/auth.ts
 function registerAuthToolsWith(server, defaultServices) {
   const servicesDescribe = `Services to authorize: "all" or comma-separated list (e.g. "sheets,gmail,calendar"). Default: "${defaultServices}". Prefer the narrowest set you need \u2014 requesting a service whose Google API is not enabled on the OAuth client's project makes Google reject the WHOLE request with invalid_scope.`;
+  const extraScopesDescribe = "Additional raw OAuth scope URIs to request, comma-separated, on top of the ones `services` implies. Use for scopes no service covers \u2014 e.g. https://www.googleapis.com/auth/bigquery.readonly, required before gog_sheets_datasource_* can read BigQuery-backed Connected Sheets. Leave unset otherwise: an extra scope whose API is not enabled on the OAuth client project makes Google reject the WHOLE authorization with invalid_scope.";
   server.registerTool("gog_auth_list", {
     description: "List the Google accounts stored in gogcli, with their scopes. This reads local configuration only \u2014 it does not contact Google and does NOT tell you whether an account still works: a signed-out account whose refresh token expired or was revoked is listed here exactly like a healthy one, scopes and all. Use gog_auth_health to check whether an account can actually authenticate.",
     annotations: { readOnlyHint: true },
@@ -31802,11 +31803,14 @@ function registerAuthToolsWith(server, defaultServices) {
     annotations: { destructiveHint: true },
     inputSchema: {
       email: external_exports.string().describe("Google account email to authorize"),
-      services: external_exports.string().optional().default(defaultServices).describe(servicesDescribe)
+      services: external_exports.string().optional().default(defaultServices).describe(servicesDescribe),
+      extraScopes: external_exports.string().optional().describe(extraScopesDescribe)
     }
-  }, async ({ email: email3, services = defaultServices }) => {
+  }, async ({ email: email3, services = defaultServices, extraScopes }) => {
     try {
-      return rawTextResult(await run(["auth", "add", email3, "--services", services], {
+      const args = ["auth", "add", email3, "--services", services];
+      if (extraScopes) args.push(`--extra-scopes=${extraScopes}`, "--force-consent");
+      return rawTextResult(await run(args, {
         interactive: true,
         timeout: 3e5
       }));
@@ -31818,14 +31822,14 @@ function registerAuthToolsWith(server, defaultServices) {
     description: "Begin REMOTE/headless Google authorization (step 1 of 2). Returns a sign-in URL to open in any browser \u2014 no local server or terminal on the gogcli host is needed, so this works over the hosted connector where the interactive gog_auth_add cannot. Hand the URL to the user; after they sign in, the browser is redirected to a localhost URL that fails to load \u2014 that is expected. They copy that full redirected URL (from the address bar) and you pass it to gog_auth_add_complete. The link is valid for 10 minutes. If you pass a custom `services` here, pass the SAME value to gog_auth_add_complete or the second step will not match this one.",
     inputSchema: {
       email: external_exports.string().describe("Google account email to authorize"),
-      services: external_exports.string().optional().default(defaultServices).describe(servicesDescribe)
+      services: external_exports.string().optional().default(defaultServices).describe(servicesDescribe),
+      extraScopes: external_exports.string().optional().describe(`${extraScopesDescribe} Pass the SAME value to gog_auth_add_complete.`)
     }
-  }, async ({ email: email3, services = defaultServices }) => {
+  }, async ({ email: email3, services = defaultServices, extraScopes }) => {
     try {
-      return rawTextResult(await run(
-        ["auth", "add", email3, "--remote", "--step", "1", "--services", services, "--force-consent"],
-        { redactMode: "tokens" }
-      ));
+      const args = ["auth", "add", email3, "--remote", "--step", "1", "--services", services, "--force-consent"];
+      if (extraScopes) args.push(`--extra-scopes=${extraScopes}`);
+      return rawTextResult(await run(args, { redactMode: "tokens" }));
     } catch (err) {
       return errorResult(errorText(err));
     }
@@ -31840,25 +31844,28 @@ function registerAuthToolsWith(server, defaultServices) {
       ),
       services: external_exports.string().optional().default(defaultServices).describe(
         `Services authorized \u2014 MUST match the value passed to gog_auth_add_url. Default: "${defaultServices}".`
+      ),
+      extraScopes: external_exports.string().optional().describe(
+        "Extra OAuth scope URIs \u2014 MUST match the value passed to gog_auth_add_url, for the same reason `services` must: the two steps have to describe the same grant."
       )
     }
-  }, async ({ email: email3, redirectUrl, services = defaultServices }) => {
+  }, async ({ email: email3, redirectUrl, services = defaultServices, extraScopes }) => {
     try {
-      return rawTextResult(await run(
-        [
-          "auth",
-          "add",
-          email3,
-          "--remote",
-          "--step",
-          "2",
-          "--auth-url",
-          redirectUrl,
-          "--services",
-          services,
-          "--force-consent"
-        ]
-      ));
+      const args = [
+        "auth",
+        "add",
+        email3,
+        "--remote",
+        "--step",
+        "2",
+        "--auth-url",
+        redirectUrl,
+        "--services",
+        services,
+        "--force-consent"
+      ];
+      if (extraScopes) args.push(`--extra-scopes=${extraScopes}`);
+      return rawTextResult(await run(args));
     } catch (err) {
       return errorResult(errorText(err));
     }
@@ -32000,16 +32007,22 @@ function registerGmailTools(server) {
     });
   });
   server.registerTool("gog_gmail_get", {
-    description: "Get a Gmail message by ID.",
+    description: "Get a Gmail message by ID. For a long message, sanitizeContent is the cheapest way to keep it in context: it drops the raw MIME payload and the HTML part, which are usually the bulk of the response.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       messageId: external_exports.string().describe("Message ID"),
       format: external_exports.enum(["full", "metadata", "raw"]).optional().describe("Message format (default: full)"),
+      // Requires gog >= 0.37.0. Before that (openclaw/gogcli#992) the JSON
+      // carried the headers and body TWICE — once inside `message`, once
+      // copied to the top level — so the flag meant to shrink the payload
+      // enlarged it. MIN_GOG_VERSION is the guard; there is no runtime check.
+      sanitizeContent: external_exports.boolean().optional().describe("Return agent-oriented sanitized content: HTML stripped, HTTP(S) URLs removed, raw Gmail payloads omitted from the JSON. The largest payload-size reduction available here. Note the URL removal is lossy \u2014 omit this when you need to follow a link out of the message."),
       account: accountParam
     }
-  }, async ({ messageId, format, account }) => {
+  }, async ({ messageId, format, sanitizeContent, account }) => {
     const args = ["gmail", "get", messageId];
     if (format) args.push(`--format=${format}`);
+    if (sanitizeContent) args.push("--sanitize-content");
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_gmail_send", {
@@ -32048,7 +32061,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.23.2" : "0.0.0";
+var VERSION = true ? "2.24.0" : "0.0.0";
 
 // ../gogcli-mcp/src/auth-log.ts
 var FAILURES = /* @__PURE__ */ new Set([
@@ -34226,7 +34239,7 @@ function registerExtraGmailTools(server) {
     args.push(f.autoFromAddressedAlias ? "--auto-from-addressed-alias" : "--auto-from-addressed-alias=false");
   }
   server.registerTool("gog_gmail_reply", {
-    description: 'Reply to a Gmail message (sends to the original sender only). Threads off the message and inherits a "Re:" subject and the quoted original by default. For replying to every participant use gog_gmail_reply_all; to reply across many messages matching a query use gog_gmail_autoreply; to stage a reply without sending use gog_gmail_drafts_create.',
+    description: 'Reply to a Gmail message (sends to the original sender only). Threads off the message and inherits a "Re:" subject and the quoted original by default. For replying to every participant use gog_gmail_reply_all; to reply across many messages matching a query use gog_gmail_autoreply; to stage this same reply without sending it use gog_gmail_drafts_reply, which composes exactly what this tool would send.',
     annotations: { destructiveHint: true },
     inputSchema: replySchema
   }, async ({ messageId, account, ...flags }) => {
@@ -34235,7 +34248,7 @@ function registerExtraGmailTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_gmail_reply_all", {
-    description: 'Reply to all participants of a Gmail message (sender plus every To/Cc recipient). Same inherited "Re:" subject and quoting as gog_gmail_reply. Use the remove flag to drop specific recipients from the reply-all.',
+    description: 'Reply to all participants of a Gmail message (sender plus every To/Cc recipient). Same inherited "Re:" subject and quoting as gog_gmail_reply. Use the remove flag to drop specific recipients from the reply-all. To stage it without sending use gog_gmail_drafts_reply_all.',
     annotations: { destructiveHint: true },
     inputSchema: replySchema
   }, async ({ messageId, account, ...flags }) => {
@@ -34243,6 +34256,46 @@ function registerExtraGmailTools(server) {
     appendReplyFlags(args, flags);
     return runOrDiagnose(args, { account });
   });
+  const draftReplyNote = ' Composes exactly what gog_gmail_reply%s would send \u2014 inherited recipients, "Re:" subject and quoted original \u2014 but SAVES IT AS A DRAFT instead of sending. Nothing leaves the mailbox; send it later with gog_gmail_drafts_send, or edit it first with gog_gmail_drafts_update (which overwrites the whole body, quote included \u2014 read the draft back before editing).';
+  server.registerTool("gog_gmail_drafts_reply", {
+    description: "Save a reply to a Gmail message as a draft (to the original sender only)." + draftReplyNote.replace("%s", "") + " Prefer this over gog_gmail_drafts_create + replyToMessageId when the draft is a real reply: that route threads the draft but leaves recipients and quoting for you to reconstruct.",
+    inputSchema: { ...replySchema, returnFull: draftWriteSchema.returnFull }
+  }, async ({ messageId, account, returnFull, ...flags }) => {
+    const args = ["gmail", "drafts", "reply", messageId];
+    appendReplyFlags(args, flags);
+    return writeDraft(args, account, returnFull);
+  });
+  server.registerTool("gog_gmail_drafts_reply_all", {
+    description: "Save a reply-all to a Gmail message as a draft (sender plus every To/Cc recipient)." + draftReplyNote.replace("%s", "_all") + " Use the remove flag to drop recipients BEFORE the draft exists, rather than editing them out afterwards.",
+    inputSchema: { ...replySchema, returnFull: draftWriteSchema.returnFull }
+  }, async ({ messageId, account, returnFull, ...flags }) => {
+    const args = ["gmail", "drafts", "reply-all", messageId];
+    appendReplyFlags(args, flags);
+    return writeDraft(args, account, returnFull);
+  });
+  server.registerTool("gog_gmail_drafts_forward", {
+    description: "Save a forward of a Gmail message as a draft. Same composition as gog_gmail_forward \u2014 the original message quoted below an optional note, with its attachments carried over \u2014 but nothing is sent. Unlike gog_gmail_forward, `to` is OPTIONAL here: omit it to stage a recipient-less forward as an accidental-send guard, then add recipients with gog_gmail_drafts_update before gog_gmail_drafts_send.",
+    inputSchema: {
+      messageId: external_exports.string().describe("Gmail message ID to forward"),
+      to: external_exports.string().optional().describe("Recipients (comma-separated). Optional for a draft \u2014 omit to stage the forward without recipients."),
+      cc: external_exports.string().optional().describe("CC recipients (comma-separated)"),
+      bcc: external_exports.string().optional().describe("BCC recipients (comma-separated)"),
+      note: external_exports.string().optional().describe("Introductory text above the forwarded message"),
+      from: external_exports.string().optional().describe("Send from this email address (must be a verified send-as alias)"),
+      skipAttachments: external_exports.boolean().optional().describe("Do not include original attachments"),
+      returnFull: draftWriteSchema.returnFull,
+      account: accountParam
+    }
+  }, async ({ messageId, to, cc, bcc, note, from, skipAttachments, returnFull, account }) => {
+    const args = ["gmail", "drafts", "forward", messageId];
+    if (to) args.push(`--to=${to}`);
+    if (cc) args.push(`--cc=${cc}`);
+    if (bcc) args.push(`--bcc=${bcc}`);
+    if (note) args.push(payloadArg("note", "note-file", note));
+    if (from) args.push(`--from=${from}`);
+    if (skipAttachments) args.push("--skip-attachments");
+    return writeDraft(args, account, returnFull);
+  });
   server.registerTool("gog_gmail_autoreply", {
     description: "Reply once to all messages matching a Gmail search query. Use the label flag to dedupe across runs.",
     annotations: { destructiveHint: true },

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.23.2",
+  "version": "2.24.0",
   "description": "Extended Gmail for Claude via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": {
     "name": "Chris Hall",
@@ -213,6 +213,18 @@
       "name": "gog_gmail_drafts_diff",
       "description": "Diff two named drafts: what each body has that the other lost, how their threading differs, and (only on a link back to the original or on agreement over unquoted text, with evidence) whether one replaced the other"
     },
+    {
+      "name": "gog_gmail_drafts_reply",
+      "description": "Save a reply to a Gmail message as a draft (inherited recipients, subject and quote; never sends)"
+    },
+    {
+      "name": "gog_gmail_drafts_reply_all",
+      "description": "Save a reply-all to a Gmail message as a draft (never sends)"
+    },
+    {
+      "name": "gog_gmail_drafts_forward",
+      "description": "Save a forward of a Gmail message as a draft; recipients are optional (never sends)"
+    },
     {
       "name": "gog_gmail_import",
       "description": "Import an RFC822/EML message into the mailbox (keeps its original headers and date; does not send)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-gmail",
-  "version": "2.23.2",
+  "version": "2.24.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-gmail",
   "description": "Extended Gmail MCP server via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/src/tools/gmail-extra.ts

@@ -3225,7 +3225,7 @@ export function registerExtraGmailTools(server: McpServer): void {
   }
 
   server.registerTool('gog_gmail_reply', {
-    description: 'Reply to a Gmail message (sends to the original sender only). Threads off the message and inherits a "Re:" subject and the quoted original by default. For replying to every participant use gog_gmail_reply_all; to reply across many messages matching a query use gog_gmail_autoreply; to stage a reply without sending use gog_gmail_drafts_create.',
+    description: 'Reply to a Gmail message (sends to the original sender only). Threads off the message and inherits a "Re:" subject and the quoted original by default. For replying to every participant use gog_gmail_reply_all; to reply across many messages matching a query use gog_gmail_autoreply; to stage this same reply without sending it use gog_gmail_drafts_reply, which composes exactly what this tool would send.',
     annotations: { destructiveHint: true },
     inputSchema: replySchema,
   }, async ({ messageId, account, ...flags }) => {
@@ -3235,7 +3235,7 @@ export function registerExtraGmailTools(server: McpServer): void {
   });
 
   server.registerTool('gog_gmail_reply_all', {
-    description: 'Reply to all participants of a Gmail message (sender plus every To/Cc recipient). Same inherited "Re:" subject and quoting as gog_gmail_reply. Use the remove flag to drop specific recipients from the reply-all.',
+    description: 'Reply to all participants of a Gmail message (sender plus every To/Cc recipient). Same inherited "Re:" subject and quoting as gog_gmail_reply. Use the remove flag to drop specific recipients from the reply-all. To stage it without sending use gog_gmail_drafts_reply_all.',
     annotations: { destructiveHint: true },
     inputSchema: replySchema,
   }, async ({ messageId, account, ...flags }) => {
@@ -3244,6 +3244,76 @@ export function registerExtraGmailTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
+  // gog >= 0.36.0: the draft-side twins of reply / reply-all / forward. They
+  // take the SAME flag set as the send-side commands and share the composition
+  // path with them, so the schemas above are reused verbatim rather than
+  // re-declared — the only difference is the subcommand and that NOTHING IS
+  // SENT.
+  //
+  // These exist because staging a reply used to mean gog_gmail_drafts_create
+  // with replyToMessageId/replyToThreadId, which threads the draft but does NOT
+  // inherit the original's recipients or quote its body — the caller had to
+  // rebuild both by hand, and a missed Cc is invisible until the draft goes
+  // out. Here the inheritance is gog's, identical to what the send path would
+  // have produced.
+  const draftReplyNote =
+    ' Composes exactly what gog_gmail_reply%s would send — inherited recipients, "Re:" subject and quoted ' +
+    'original — but SAVES IT AS A DRAFT instead of sending. Nothing leaves the mailbox; send it later with ' +
+    'gog_gmail_drafts_send, or edit it first with gog_gmail_drafts_update (which overwrites the whole body, ' +
+    'quote included — read the draft back before editing).';
+
+  server.registerTool('gog_gmail_drafts_reply', {
+    description:
+      'Save a reply to a Gmail message as a draft (to the original sender only).' + draftReplyNote.replace('%s', '') +
+      ' Prefer this over gog_gmail_drafts_create + replyToMessageId when the draft is a real reply: that route threads ' +
+      'the draft but leaves recipients and quoting for you to reconstruct.',
+    inputSchema: { ...replySchema, returnFull: draftWriteSchema.returnFull },
+  }, async ({ messageId, account, returnFull, ...flags }) => {
+    const args: GogArg[] = ['gmail', 'drafts', 'reply', messageId];
+    appendReplyFlags(args, flags);
+    return writeDraft(args, account, returnFull);
+  });
+
+  server.registerTool('gog_gmail_drafts_reply_all', {
+    description:
+      'Save a reply-all to a Gmail message as a draft (sender plus every To/Cc recipient).' +
+      draftReplyNote.replace('%s', '_all') +
+      ' Use the remove flag to drop recipients BEFORE the draft exists, rather than editing them out afterwards.',
+    inputSchema: { ...replySchema, returnFull: draftWriteSchema.returnFull },
+  }, async ({ messageId, account, returnFull, ...flags }) => {
+    const args: GogArg[] = ['gmail', 'drafts', 'reply-all', messageId];
+    appendReplyFlags(args, flags);
+    return writeDraft(args, account, returnFull);
+  });
+
+  server.registerTool('gog_gmail_drafts_forward', {
+    description:
+      'Save a forward of a Gmail message as a draft. Same composition as gog_gmail_forward — the original ' +
+      'message quoted below an optional note, with its attachments carried over — but nothing is sent. ' +
+      'Unlike gog_gmail_forward, `to` is OPTIONAL here: omit it to stage a recipient-less forward as an ' +
+      'accidental-send guard, then add recipients with gog_gmail_drafts_update before gog_gmail_drafts_send.',
+    inputSchema: {
+      messageId: z.string().describe('Gmail message ID to forward'),
+      to: z.string().optional().describe('Recipients (comma-separated). Optional for a draft — omit to stage the forward without recipients.'),
+      cc: z.string().optional().describe('CC recipients (comma-separated)'),
+      bcc: z.string().optional().describe('BCC recipients (comma-separated)'),
+      note: z.string().optional().describe('Introductory text above the forwarded message'),
+      from: z.string().optional().describe('Send from this email address (must be a verified send-as alias)'),
+      skipAttachments: z.boolean().optional().describe('Do not include original attachments'),
+      returnFull: draftWriteSchema.returnFull,
+      account: accountParam,
+    },
+  }, async ({ messageId, to, cc, bcc, note, from, skipAttachments, returnFull, account }) => {
+    const args: GogArg[] = ['gmail', 'drafts', 'forward', messageId];
+    if (to) args.push(`--to=${to}`);
+    if (cc) args.push(`--cc=${cc}`);
+    if (bcc) args.push(`--bcc=${bcc}`);
+    if (note) args.push(payloadArg('note', 'note-file', note));
+    if (from) args.push(`--from=${from}`);
+    if (skipAttachments) args.push('--skip-attachments');
+    return writeDraft(args, account, returnFull);
+  });
+
   server.registerTool('gog_gmail_autoreply', {
     description: 'Reply once to all messages matching a Gmail search query. Use the label flag to dedupe across runs.',
     annotations: { destructiveHint: true },

package/tests/tools/gmail-extra.test.ts

@@ -1669,6 +1669,139 @@ describe('gog_gmail_reply_all', () => {
   });
 });
 
+// gog 0.36.0 (openclaw/gogcli#977) added the draft-side twins of reply /
+// reply-all / forward. The point of these tests is the SUBCOMMAND: the flag
+// handling is the send path's, shared verbatim, and a copy of it here would
+// only re-assert what the reply tests above already pin. What is new — and what
+// a regression would silently break — is that these route to `drafts <verb>`
+// and therefore never send.
+describe('gog_gmail_drafts_reply', () => {
+  it('routes to gmail drafts reply, not the sending reply', async () => {
+    await harness.callTool('gog_gmail_drafts_reply', { messageId: 'm1', body: 'Thanks' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'reply', 'm1', '--body=Thanks', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+  });
+
+  it('passes the shared reply flag set through unchanged', async () => {
+    await harness.callTool('gog_gmail_drafts_reply', {
+      messageId: 'm1',
+      body: 'Hi',
+      to: ['a@b.com'],
+      cc: ['cc@x.com'],
+      remove: ['old@x.com'],
+      subject: 'New subject',
+      noQuote: true,
+      attach: ['/tmp/a.pdf'],
+      from: 'me@x.com',
+      signature: true,
+      account: 'me@gmail.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'drafts', 'reply', 'm1',
+        '--body=Hi',
+        '--to=a@b.com',
+        '--cc=cc@x.com',
+        '--remove=old@x.com',
+        '--subject=New subject',
+        '--no-quote',
+        '--attach=/tmp/a.pdf',
+        '--from=me@x.com',
+        '--signature',
+        '--auto-from-addressed-alias=false',
+      ],
+      { account: 'me@gmail.com' },
+    );
+  });
+
+  it('returnFull re-fetches the saved draft and never reaches the CLI as a flag', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(rawTextResult('{"draftId":"d9"}'))
+      .mockResolvedValueOnce(rawTextResult('{"id":"d9","message":{"subject":"Re: Hi"}}'));
+    const result = await harness.callTool('gog_gmail_drafts_reply', {
+      messageId: 'm1', body: 'Hi', returnFull: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(1,
+      ['gmail', 'drafts', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
+      ['gmail', 'drafts', 'get', 'd9', '--use-indexed-attachment-ids=false'], { account: undefined });
+    expect(result.content[0].text).toContain('"subject":"Re: Hi"');
+  });
+});
+
+describe('gog_gmail_drafts_reply_all', () => {
+  it('routes to gmail drafts reply-all', async () => {
+    await harness.callTool('gog_gmail_drafts_reply_all', { messageId: 'm1', body: 'Thanks all' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'reply-all', 'm1', '--body=Thanks all', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+  });
+
+  it('carries repeatable recipient removals onto the draft', async () => {
+    await harness.callTool('gog_gmail_drafts_reply_all', {
+      messageId: 'm1', body: 'Hi', remove: ['drop@y.com', 'also@y.com'],
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'drafts', 'reply-all', 'm1',
+        '--body=Hi',
+        '--remove=drop@y.com',
+        '--remove=also@y.com',
+        '--auto-from-addressed-alias=false',
+      ],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_forward', () => {
+  it('omits --to entirely when no recipients are given', async () => {
+    await harness.callTool('gog_gmail_drafts_forward', { messageId: 'm1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'forward', 'm1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes every forward flag', async () => {
+    await harness.callTool('gog_gmail_drafts_forward', {
+      messageId: 'm1',
+      to: 'a@b.com,c@d.com',
+      cc: 'cc@x.com',
+      bcc: 'bcc@x.com',
+      note: 'FYI',
+      from: 'me@x.com',
+      skipAttachments: true,
+      account: 'me@gmail.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'drafts', 'forward', 'm1',
+        '--to=a@b.com,c@d.com',
+        '--cc=cc@x.com',
+        '--bcc=bcc@x.com',
+        '--note=FYI',
+        '--from=me@x.com',
+        '--skip-attachments',
+      ],
+      { account: 'me@gmail.com' },
+    );
+  });
+
+  it('returnFull re-fetches the saved forward draft', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(rawTextResult('{"draftId":"d7"}'))
+      .mockResolvedValueOnce(rawTextResult('{"id":"d7","message":{"subject":"Fwd: Hi"}}'));
+    const result = await harness.callTool('gog_gmail_drafts_forward', { messageId: 'm1', returnFull: true });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
+      ['gmail', 'drafts', 'get', 'd7', '--use-indexed-attachment-ids=false'], { account: undefined });
+    expect(result.content[0].text).toContain('"subject":"Fwd: Hi"');
+  });
+});
+
 describe('gog_gmail_autoreply', () => {
   it('calls runOrDiagnose with query and --body', async () => {
     await harness.callTool('gog_gmail_autoreply', { query: 'is:unread', body: 'Thanks' });