gogcli-mcp-gmail 2.4.1 → 2.5.0

package/dist/index.js

@@ -31274,14 +31274,16 @@ function registerGmailTools(server2) {
       bcc: external_exports.string().optional().describe("BCC recipients, comma-separated"),
       replyToMessageId: external_exports.string().optional().describe("Message ID to reply to"),
       threadId: external_exports.string().optional().describe("Thread ID to reply within"),
+      attach: external_exports.array(external_exports.string()).optional().describe("Local file paths to attach (repeatable). Each file is read on the gog server (not this client), base64-encoded with a MIME type inferred from its extension, and added as a multipart attachment. Keep the total under Gmail's ~35 MB inline-upload limit."),
       account: accountParam
     }
-  }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, account }) => {
+  }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, attach, account }) => {
     const args = ["gmail", "send", `--to=${to}`, `--subject=${subject}`, `--body=${body}`];
     if (cc) args.push(`--cc=${cc}`);
     if (bcc) args.push(`--bcc=${bcc}`);
     if (replyToMessageId) args.push(`--reply-to-message-id=${replyToMessageId}`);
     if (threadId) args.push(`--thread-id=${threadId}`);
+    if (attach) for (const path of attach) args.push(`--attach=${path}`);
     return runOrDiagnose(args, { account });
   });
   registerRunTool(server2, { service: "gmail", examples: '"archive", "mark-read", "labels"' });
@@ -31297,7 +31299,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.4.1" : "0.0.0";
+var VERSION = true ? "2.5.0" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31631,10 +31633,10 @@ function registerExtraGmailTools(server2) {
     body: external_exports.string().describe("Body (plain text)"),
     bodyHtml: external_exports.string().optional().describe("Body (HTML; optional)"),
     replyToMessageId: external_exports.string().optional().describe("Reply to a specific Gmail MESSAGE id \u2014 the short hex `id` field from gog_gmail_get / _search / _thread_get (e.g. 19e7593d77fd9636), NOT a thread id and NOT the RFC822 `<\u2026@host>` Message-Id header. Anchors In-Reply-To/References to that exact message. To reply to a thread when you don't know the latest message, use replyToThreadId instead. If both are given, replyToMessageId wins."),
-    replyToThreadId: external_exports.string().optional().describe(`Reply to a Gmail THREAD id \u2014 the wrapper resolves the thread's most recent message and anchors the reply (In-Reply-To/References) to it. This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse \u2014 use this param, not replyToMessageId, when the id came from a thread.`),
+    replyToThreadId: external_exports.string().optional().describe(`Reply to a Gmail THREAD id \u2014 passed to gog as --thread-id, which threads the draft using the thread's latest-message headers (In-Reply-To/References). This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse \u2014 use this param, not replyToMessageId, when the id came from a thread.`),
     replyTo: external_exports.string().optional().describe("Reply-To header address"),
     quote: external_exports.boolean().optional().describe("Include quoted original message in reply (requires replyToMessageId or replyToThreadId)"),
-    attach: external_exports.array(external_exports.string()).optional().describe("Attachment file paths (repeatable)"),
+    attach: external_exports.array(external_exports.string()).optional().describe("Local file paths to attach (repeatable). Read on the gog server, base64-encoded with a MIME type inferred from the extension. On gog_gmail_drafts_update, supplying attach REPLACES the draft's existing attachments; omitting it preserves them (use clearAttachments to remove all)."),
     from: external_exports.string().optional().describe("Send from this email address (must be a verified send-as alias)"),
     omitRecipients: external_exports.boolean().optional().describe("Create the draft with no recipients even if to/cc/bcc are supplied \u2014 an accidental-send guard. Populate recipients in a later update before sending."),
     returnFull: external_exports.boolean().optional().describe("After writing, re-fetch and return the full stored draft (subject, body, recipients) instead of just the write acknowledgement. Costs one extra read."),
@@ -31650,28 +31652,12 @@ function registerExtraGmailTools(server2) {
     args.push(`--body=${f.body}`);
     if (f.bodyHtml) args.push(`--body-html=${f.bodyHtml}`);
     if (f.replyToMessageId) args.push(`--reply-to-message-id=${f.replyToMessageId}`);
+    else if (f.replyToThreadId) args.push(`--thread-id=${f.replyToThreadId}`);
     if (f.replyTo) args.push(`--reply-to=${f.replyTo}`);
     if (f.quote) args.push("--quote");
     if (f.attach) for (const path of f.attach) args.push(`--attach=${path}`);
     if (f.from) args.push(`--from=${f.from}`);
   }
-  async function resolveReplyTarget(replyToMessageId, replyToThreadId, account) {
-    if (replyToMessageId) return { messageId: replyToMessageId };
-    if (!replyToThreadId) return { messageId: void 0 };
-    const threadResult = await runOrDiagnose(["gmail", "thread", "get", replyToThreadId], { account });
-    let parsed;
-    try {
-      parsed = JSON.parse(threadResult.content[0].text);
-    } catch {
-      return { error: threadResult };
-    }
-    const messages = parsed.thread?.messages;
-    const latest = Array.isArray(messages) ? messages[messages.length - 1] : void 0;
-    if (!latest?.id) {
-      return { error: toText(`Error: thread ${replyToThreadId} has no message to reply to`) };
-    }
-    return { messageId: latest.id };
-  }
   async function writeDraft(args, account, returnFull, knownDraftId) {
     const result = await runOrDiagnose(args, { account });
     if (!returnFull) return result;
@@ -31688,25 +31674,23 @@ function registerExtraGmailTools(server2) {
   server2.registerTool("gog_gmail_drafts_create", {
     description: "Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard. For replies, prefer replyToThreadId (anchors to the thread's latest message) or replyToMessageId (a specific message) \u2014 don't pass a thread id into replyToMessageId, which mis-threads silently.",
     inputSchema: draftWriteSchema
-  }, async ({ account, returnFull, replyToThreadId, ...flags }) => {
-    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
-    if ("error" in resolved) return resolved.error;
+  }, async ({ account, returnFull, ...flags }) => {
     const args = ["gmail", "drafts", "create"];
-    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
+    appendDraftFlags(args, flags);
     return writeDraft(args, account, returnFull);
   });
   server2.registerTool("gog_gmail_drafts_update", {
-    description: "Update an existing Gmail draft. For replies, prefer replyToThreadId (anchors to the thread's latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId.",
+    description: "Update an existing Gmail draft. For replies, prefer replyToThreadId (threads off the thread's latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId. Attachment semantics: supplying attach REPLACES the draft's existing attachments; omitting it preserves them; set clearAttachments to remove all.",
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: external_exports.string().describe("Draft ID"),
-      ...draftWriteSchema
+      ...draftWriteSchema,
+      clearAttachments: external_exports.boolean().optional().describe("Remove all attachments from the draft. By default, omitting attach preserves the draft's existing attachments; this intentionally clears them. Ignored if attach is also supplied (attach replaces).")
     }
-  }, async ({ draftId, account, returnFull, replyToThreadId, ...flags }) => {
-    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
-    if ("error" in resolved) return resolved.error;
+  }, async ({ draftId, account, returnFull, clearAttachments, ...flags }) => {
     const args = ["gmail", "drafts", "update", draftId];
-    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
+    appendDraftFlags(args, flags);
+    if (clearAttachments) args.push("--clear-attachments");
     return writeDraft(args, account, returnFull, draftId);
   });
   server2.registerTool("gog_gmail_drafts_delete", {

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Extended Gmail for Claude via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-gmail",
-  "version": "2.4.1",
+  "version": "2.5.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

@@ -372,10 +372,10 @@ export function registerExtraGmailTools(server: McpServer): void {
     body: z.string().describe('Body (plain text)'),
     bodyHtml: z.string().optional().describe('Body (HTML; optional)'),
     replyToMessageId: z.string().optional().describe('Reply to a specific Gmail MESSAGE id — the short hex `id` field from gog_gmail_get / _search / _thread_get (e.g. 19e7593d77fd9636), NOT a thread id and NOT the RFC822 `<…@host>` Message-Id header. Anchors In-Reply-To/References to that exact message. To reply to a thread when you don\'t know the latest message, use replyToThreadId instead. If both are given, replyToMessageId wins.'),
-    replyToThreadId: z.string().optional().describe('Reply to a Gmail THREAD id — the wrapper resolves the thread\'s most recent message and anchors the reply (In-Reply-To/References) to it. This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse — use this param, not replyToMessageId, when the id came from a thread.'),
+    replyToThreadId: z.string().optional().describe('Reply to a Gmail THREAD id — passed to gog as --thread-id, which threads the draft using the thread\'s latest-message headers (In-Reply-To/References). This is what "reply to this thread" almost always means. Mutually exclusive with replyToMessageId (which wins if both are set). Thread ids and message ids are both 16-hex strings and easy to confuse — use this param, not replyToMessageId, when the id came from a thread.'),
     replyTo: z.string().optional().describe('Reply-To header address'),
     quote: z.boolean().optional().describe('Include quoted original message in reply (requires replyToMessageId or replyToThreadId)'),
-    attach: z.array(z.string()).optional().describe('Attachment file paths (repeatable)'),
+    attach: z.array(z.string()).optional().describe('Local file paths to attach (repeatable). Read on the gog server, base64-encoded with a MIME type inferred from the extension. On gog_gmail_drafts_update, supplying attach REPLACES the draft\'s existing attachments; omitting it preserves them (use clearAttachments to remove all).'),
     from: z.string().optional().describe('Send from this email address (must be a verified send-as alias)'),
     omitRecipients: z.boolean().optional().describe('Create the draft with no recipients even if to/cc/bcc are supplied — an accidental-send guard. Populate recipients in a later update before sending.'),
     returnFull: z.boolean().optional().describe('After writing, re-fetch and return the full stored draft (subject, body, recipients) instead of just the write acknowledgement. Costs one extra read.'),
@@ -390,6 +390,7 @@ export function registerExtraGmailTools(server: McpServer): void {
     body: string;
     bodyHtml?: string;
     replyToMessageId?: string;
+    replyToThreadId?: string;
     replyTo?: string;
     quote?: boolean;
     attach?: string[];
@@ -406,47 +407,17 @@ export function registerExtraGmailTools(server: McpServer): void {
     args.push(`--subject=${f.subject}`);
     args.push(`--body=${f.body}`);
     if (f.bodyHtml) args.push(`--body-html=${f.bodyHtml}`);
+    // A draft can reply to a specific message (--reply-to-message-id) or thread
+    // off the latest message in a thread (--thread-id, which gog resolves
+    // server-side). replyToMessageId wins when both are supplied.
     if (f.replyToMessageId) args.push(`--reply-to-message-id=${f.replyToMessageId}`);
+    else if (f.replyToThreadId) args.push(`--thread-id=${f.replyToThreadId}`);
     if (f.replyTo) args.push(`--reply-to=${f.replyTo}`);
     if (f.quote) args.push('--quote');
     if (f.attach) for (const path of f.attach) args.push(`--attach=${path}`);
     if (f.from) args.push(`--from=${f.from}`);
   }
 
-  // Resolve the effective reply target for a draft write. A draft can only
-  // thread off a specific MESSAGE id, but callers usually have a THREAD id and
-  // mean "reply to this thread". gog's `drafts create/update` has no --thread-id
-  // (unlike `gmail send`), so we resolve thread -> latest message here and pass
-  // that message id — gog then sets In-Reply-To/References from its RFC822
-  // Message-Id. replyToMessageId always wins; when only a thread id is given we
-  // fetch the thread and reply to its most recent message. Returns either the
-  // resolved message id (possibly undefined when neither was supplied) or an
-  // error ToolResult that the handler surfaces instead of writing a
-  // mis-threaded draft. (When upstream adds --thread-id to drafts — openclaw/
-  // gogcli#673 — this can pass it through directly with no MCP surface change.)
-  async function resolveReplyTarget(
-    replyToMessageId: string | undefined,
-    replyToThreadId: string | undefined,
-    account: string | undefined,
-  ): Promise<{ messageId?: string } | { error: ToolResult }> {
-    if (replyToMessageId) return { messageId: replyToMessageId };
-    if (!replyToThreadId) return { messageId: undefined };
-    const threadResult = await runOrDiagnose(['gmail', 'thread', 'get', replyToThreadId], { account });
-    let parsed: { thread?: { messages?: GmailMessage[] } };
-    try {
-      parsed = JSON.parse(threadResult.content[0].text) as { thread?: { messages?: GmailMessage[] } };
-    } catch {
-      // Non-JSON output means the thread fetch itself errored — surface it.
-      return { error: threadResult };
-    }
-    const messages = parsed.thread?.messages;
-    const latest = Array.isArray(messages) ? messages[messages.length - 1] : undefined;
-    if (!latest?.id) {
-      return { error: toText(`Error: thread ${replyToThreadId} has no message to reply to`) };
-    }
-    return { messageId: latest.id };
-  }
-
   // Run a draft write, then — when returnFull is set — re-fetch the stored
   // draft so the caller can verify subject/body/recipients persisted without a
   // separate gog_gmail_drafts_get round trip. For updates the id is known up
@@ -478,26 +449,24 @@ export function registerExtraGmailTools(server: McpServer): void {
   server.registerTool('gog_gmail_drafts_create', {
     description: 'Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard. For replies, prefer replyToThreadId (anchors to the thread\'s latest message) or replyToMessageId (a specific message) — don\'t pass a thread id into replyToMessageId, which mis-threads silently.',
     inputSchema: draftWriteSchema,
-  }, async ({ account, returnFull, replyToThreadId, ...flags }) => {
-    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
-    if ('error' in resolved) return resolved.error;
+  }, async ({ account, returnFull, ...flags }) => {
     const args = ['gmail', 'drafts', 'create'];
-    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
+    appendDraftFlags(args, flags);
     return writeDraft(args, account, returnFull);
   });
 
   server.registerTool('gog_gmail_drafts_update', {
-    description: 'Update an existing Gmail draft. For replies, prefer replyToThreadId (anchors to the thread\'s latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId.',
+    description: 'Update an existing Gmail draft. For replies, prefer replyToThreadId (threads off the thread\'s latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId. Attachment semantics: supplying attach REPLACES the draft\'s existing attachments; omitting it preserves them; set clearAttachments to remove all.',
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: z.string().describe('Draft ID'),
       ...draftWriteSchema,
+      clearAttachments: z.boolean().optional().describe('Remove all attachments from the draft. By default, omitting attach preserves the draft\'s existing attachments; this intentionally clears them. Ignored if attach is also supplied (attach replaces).'),
     },
-  }, async ({ draftId, account, returnFull, replyToThreadId, ...flags }) => {
-    const resolved = await resolveReplyTarget(flags.replyToMessageId, replyToThreadId, account);
-    if ('error' in resolved) return resolved.error;
+  }, async ({ draftId, account, returnFull, clearAttachments, ...flags }) => {
     const args = ['gmail', 'drafts', 'update', draftId];
-    appendDraftFlags(args, { ...flags, replyToMessageId: resolved.messageId });
+    appendDraftFlags(args, flags);
+    if (clearAttachments) args.push('--clear-attachments');
     return writeDraft(args, account, returnFull, draftId);
   });
 

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

@@ -545,84 +545,39 @@ describe('gog_gmail_drafts_create', () => {
   });
 });
 
-describe('gmail draft reply threading (replyToThreadId resolution)', () => {
-  const threadJson = (ids: (string | undefined)[]) =>
-    toText(JSON.stringify({ thread: { messages: ids.map((id) => (id ? { id } : {})) } }));
-
-  it('resolves replyToThreadId to the thread\'s latest message id on create', async () => {
-    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
-      if (args[1] === 'thread' && args[2] === 'get') return threadJson(['m1', 'm2', 'mLatest']);
-      return toText('{"draftId":"d1"}');
-    });
+describe('gmail draft reply threading (native --thread-id)', () => {
+  it('passes replyToThreadId straight through as --thread-id on create (no thread fetch)', async () => {
     await handlers.get('gog_gmail_drafts_create')!({
       subject: 'Re: roof', body: 'Sounds good', replyToThreadId: '19dffe06f9668b28', account: 'me@x.com',
     });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'thread', 'get', '19dffe06f9668b28'], { account: 'me@x.com' });
+    // gog resolves the thread's latest-message headers itself — no extra fetch.
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'create', '--subject=Re: roof', '--body=Sounds good', '--reply-to-message-id=mLatest'],
+      ['gmail', 'drafts', 'create', '--subject=Re: roof', '--body=Sounds good', '--thread-id=19dffe06f9668b28'],
       { account: 'me@x.com' },
     );
   });
 
-  it('resolves replyToThreadId on update too', async () => {
-    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
-      if (args[1] === 'thread' && args[2] === 'get') return threadJson(['a', 'b']);
-      return toText('{"draftId":"d1"}');
-    });
+  it('passes replyToThreadId as --thread-id on update', async () => {
     await handlers.get('gog_gmail_drafts_update')!({
       draftId: 'd1', subject: 'S', body: 'B', replyToThreadId: 't1',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--reply-to-message-id=b'],
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--thread-id=t1'],
       { account: undefined },
     );
   });
 
-  it('replyToMessageId wins when both ids are supplied (no thread fetch)', async () => {
+  it('replyToMessageId wins when both ids are supplied (no --thread-id)', async () => {
     await handlers.get('gog_gmail_drafts_create')!({
       subject: 'S', body: 'B', replyToMessageId: 'mExplicit', replyToThreadId: 't1',
     });
-    // Only the create call — the thread was never fetched.
     expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['gmail', 'drafts', 'create', '--subject=S', '--body=B', '--reply-to-message-id=mExplicit'],
       { account: undefined },
     );
   });
-
-  it('surfaces the thread-fetch error and does not write a mis-threaded draft', async () => {
-    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('Error: thread t1 not found'));
-    const result = await handlers.get('gog_gmail_drafts_create')!({
-      subject: 'S', body: 'B', replyToThreadId: 't1',
-    });
-    expect(result.content[0].text).toBe('Error: thread t1 not found');
-    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1); // only the thread fetch; no create
-  });
-
-  it('errors when the thread has no message to reply to', async () => {
-    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(JSON.stringify({ thread: { messages: [] } })));
-    const result = await handlers.get('gog_gmail_drafts_create')!({
-      subject: 'S', body: 'B', replyToThreadId: 't1',
-    });
-    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
-    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
-  });
-
-  it('errors when the thread payload has no messages array', async () => {
-    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('{}'));
-    const result = await handlers.get('gog_gmail_drafts_create')!({
-      subject: 'S', body: 'B', replyToThreadId: 't1',
-    });
-    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
-  });
-
-  it('errors when the latest message has no id', async () => {
-    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(threadJson(['m1', undefined]));
-    const result = await handlers.get('gog_gmail_drafts_create')!({
-      subject: 'S', body: 'B', replyToThreadId: 't1',
-    });
-    expect(result.content[0].text).toBe('Error: thread t1 has no message to reply to');
-  });
 });
 
 describe('gog_gmail_drafts_update', () => {
@@ -661,6 +616,16 @@ describe('gog_gmail_drafts_update', () => {
     );
   });
 
+  it('passes --clear-attachments when clearAttachments is true', async () => {
+    await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1', subject: 'S', body: 'B', clearAttachments: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--clear-attachments'],
+      { account: undefined },
+    );
+  });
+
   it('returnFull re-fetches the draft by its known id', async () => {
     vi.mocked(lib.runOrDiagnose)
       .mockResolvedValueOnce(toText('{"draftId":"d1"}'))