gogcli-mcp-gmail 2.23.0 → 2.23.1

package/dist/index.js

@@ -31896,7 +31896,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.23.0" : "0.0.0";
+var VERSION = true ? "2.23.1" : "0.0.0";
 
 // ../gogcli-mcp/src/auth-log.ts
 var FAILURES = /* @__PURE__ */ new Set([
@@ -33875,14 +33875,17 @@ function registerExtraGmailTools(server) {
     if (f.from) args.push(`--from=${f.from}`);
     args.push(f.autoFromAddressedAlias ? "--auto-from-addressed-alias" : "--auto-from-addressed-alias=false");
   }
-  function withRefetchNote(written, draftId) {
+  function withRefetchNote(written, draftId, refetch) {
+    const detail = resultText(refetch)?.trim();
+    const looksForked = detail !== void 0 && DRAFT_NOT_FOUND_PATTERN.test(detail);
+    const because = looksForked ? "the id did not resolve, which on this mailbox usually means the draft was forked by a mail client between the write and the read. Run gog_gmail_drafts_list to find the current id" : `the read failed for a different reason, reported verbatim here: ${detail ?? "(no detail supplied)"}. That is a failure of the READ ONLY`;
     return {
       ...written,
       content: [
         ...written.content,
         {
           type: "text",
-          text: `Note: the write to draft ${draftId} SUCCEEDED and is acknowledged above. The follow-up read-back requested by returnFull could not be performed \u2014 the id did not resolve, which on this mailbox usually means the draft was forked by a mail client between the write and the read. Nothing was lost. Run gog_gmail_drafts_list to find the current id, or gog_gmail_drafts_get on ${draftId} to confirm.`
+          text: `Note: the write to draft ${draftId} SUCCEEDED and is acknowledged above. The follow-up read-back requested by returnFull could not be performed \u2014 ${because}. Nothing was lost; run gog_gmail_drafts_get on ${draftId} to confirm the saved content.`
         }
       ]
     };
@@ -33904,7 +33907,7 @@ function registerExtraGmailTools(server) {
       if (draftId) {
         const refetched = await runOrDiagnose(["gmail", "drafts", "get", draftId, "--use-indexed-attachment-ids=false"], { account });
         if (refetched.isError !== true) final = refetched;
-        else final = withRefetchNote(result, draftId);
+        else final = withRefetchNote(result, draftId, refetched);
       }
     }
     if (!verification) return final;

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.23.0",
+  "version": "2.23.1",
   "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.23.0",
+  "version": "2.23.1",
   "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

@@ -2905,8 +2905,22 @@ export function registerExtraGmailTools(server: McpServer): void {
   // the raw write result if the id can't be determined.
   /** The write succeeded; only the `returnFull` re-read did not. Hand back the
    *  acknowledgement, and say plainly which half failed — a caller that cannot
-   *  tell those apart will either re-send or delete the wrong copy. */
-  function withRefetchNote(written: CallToolResult, draftId: string): CallToolResult {
+   *  tell those apart will either re-send or delete the wrong copy.
+   *
+   *  A missing id and any OTHER read failure are different stories and get
+   *  different text. Gating on DRAFT_NOT_FOUND_PATTERN — the same test
+   *  forkAwareDraftFailure uses — keeps the fork explanation for the case that
+   *  actually looks like one; a permission error, a timeout or a transport fault
+   *  keeps its own message instead of being retold as a fork, which would both
+   *  mislead and discard the only text saying what really went wrong. */
+  function withRefetchNote(written: CallToolResult, draftId: string, refetch: CallToolResult): CallToolResult {
+    const detail = resultText(refetch)?.trim();
+    const looksForked = detail !== undefined && DRAFT_NOT_FOUND_PATTERN.test(detail);
+    const because = looksForked
+      ? 'the id did not resolve, which on this mailbox usually means the draft was forked by a mail client ' +
+        'between the write and the read. Run gog_gmail_drafts_list to find the current id'
+      : `the read failed for a different reason, reported verbatim here: ${detail ?? '(no detail supplied)'}. ` +
+        'That is a failure of the READ ONLY';
     return {
       ...written,
       content: [
@@ -2915,10 +2929,8 @@ export function registerExtraGmailTools(server: McpServer): void {
           type: 'text' as const,
           text:
             `Note: the write to draft ${draftId} SUCCEEDED and is acknowledged above. The follow-up ` +
-            'read-back requested by returnFull could not be performed — the id did not resolve, which on ' +
-            'this mailbox usually means the draft was forked by a mail client between the write and the ' +
-            `read. Nothing was lost. Run gog_gmail_drafts_list to find the current id, or ` +
-            `gog_gmail_drafts_get on ${draftId} to confirm.`,
+            `read-back requested by returnFull could not be performed — ${because}. Nothing was lost; ` +
+            `run gog_gmail_drafts_get on ${draftId} to confirm the saved content.`,
         },
       ],
     };
@@ -2969,7 +2981,7 @@ export function registerExtraGmailTools(server: McpServer): void {
         // most destructive thing this tool can say to someone about to tidy up
         // the sibling copy.
         if (refetched.isError !== true) final = refetched;
-        else final = withRefetchNote(result, draftId);
+        else final = withRefetchNote(result, draftId, refetched);
       }
     }
     if (!verification) return final;

package/tests/tools/draft-diff-arithmetic.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerExtraGmailTools } from '../../src/tools/gmail-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+import { createTestHarness, type TestHarness } from '@chrischall/mcp-utils/test';
+import { rawTextResult, errorResult } from '@chrischall/mcp-utils';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (o) => ({ ...(await o<typeof lib>()), run: vi.fn(), runOrDiagnose: vi.fn(), diagnose: vi.fn() }));
+
+let harness: TestHarness;
+beforeEach(async () => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+  vi.mocked(lib.diagnose).mockResolvedValue(errorResult('diagnosed'));
+  harness = await createTestHarness(registerExtraGmailTools);
+});
+
+const b64 = (t: string) => Buffer.from(t, 'utf8').toString('base64url');
+const draft = (id: string, body: string) => JSON.stringify({
+  draft: {
+    id,
+    message: { id: `m${id}`, threadId: `t${id}`, payload: { mimeType: 'text/plain', headers: [{ name: 'Subject', value: 'S' }], body: { data: b64(body) } } },
+  },
+});
+
+/**
+ * #264: bodyLineCount counted RAW normalized lines while diffBodyLines compares
+ * Set members, so onlyInACount + sharedLineCount === bodyLineCount stopped
+ * holding the moment a body repeated a line. Dividers repeat constantly in real
+ * mail, so this is the ordinary case, not an edge one.
+ *
+ * Asserted through the TOOL, against the emitted payload, because
+ * describeDraftSide is module-private — and because the payload is what a
+ * caller actually does arithmetic on.
+ */
+const A = ['Intro paragraph.', '---', 'Middle paragraph.', '---', 'Closing paragraph.'].join('\n');
+const B = ['Intro paragraph.', '---', 'A different middle.', '---', 'Closing paragraph.'].join('\n');
+
+describe('gog_gmail_drafts_diff count arithmetic', () => {
+  it('onlyInACount + sharedLineCount === bodyLineCount when a body repeats a line', async () => {
+    vi.mocked(lib.run).mockImplementation(async (args: readonly string[]) =>
+      draft(String(args[3]), String(args[3]) === 'a1' ? A : B));
+
+    const res = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a1', draftIdB: 'b1' });
+    const raw = res.content.map((c: any) => c.text).join('\n');
+    const payload = JSON.parse(raw);
+
+    const sideA = payload.drafts.a;
+    const diff = payload.bodyDiff;
+
+    expect(sideA.bodyLineCount).toBeDefined();
+    expect(diff.onlyInACount).toBeDefined();
+    expect(diff.sharedLineCount).toBeDefined();
+    // The body has 5 raw lines but only 4 distinct ones — that gap is the bug.
+    expect(sideA.bodyLineCount).toBe(4);
+    expect(diff.onlyInACount + diff.sharedLineCount).toBe(sideA.bodyLineCount);
+  });
+});

package/tests/tools/draft-write-vs-refetch.test.ts

@@ -53,6 +53,43 @@ describe('a failed returnFull re-read does not erase a successful write', () =>
     expect(res.content.map((c: any) => c.text).join('\n')).toContain('payload');
   });
 
+  it('does NOT retell a non-404 read failure as a fork, and keeps its text', async () => {
+    // #264: any refetch failure used to get the fork explanation, discarding the
+    // only text saying what actually went wrong. A permission error is not a fork.
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: readonly string[]) =>
+      args[2] === 'update' ? rawTextResult(ack) : errorResult('Google API error (403 forbidden): insufficient permission'));
+
+    const res = await harness.callTool('gog_gmail_drafts_update', { draftId: 'r123', subject: 'S', body: 'x', returnFull: true });
+    const text = res.content.map((c: any) => c.text).join('\n');
+
+    expect(res.isError).not.toBe(true);
+    expect(text).toContain('SUCCEEDED');
+    expect(text).toContain('403 forbidden');            // the real cause survives
+    expect(text).not.toMatch(/forked by a mail client/); // and is not retold as a fork
+  });
+
+  it('still gives the fork explanation on a genuine 404', async () => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: readonly string[]) =>
+      args[2] === 'update' ? rawTextResult(ack) : errorResult('Google API error (404 notFound)'));
+    const res = await harness.callTool('gog_gmail_drafts_update', { draftId: 'r123', subject: 'S', body: 'x', returnFull: true });
+    expect(res.content.map((c: any) => c.text).join('\n')).toMatch(/forked by a mail client/);
+  });
+
+  it('still says the write succeeded when the read failure carries no text', async () => {
+    // An error result with no content at all: the note must not interpolate
+    // `undefined` into the sentence a caller reads to decide what to do next.
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: readonly string[]) =>
+      args[2] === 'update' ? rawTextResult(ack) : ({ isError: true, content: [] } as any));
+
+    const res = await harness.callTool('gog_gmail_drafts_update', { draftId: 'r123', subject: 'S', body: 'x', returnFull: true });
+    const text = res.content.map((c: any) => c.text).join('\n');
+
+    expect(res.isError).not.toBe(true);
+    expect(text).toContain('SUCCEEDED');
+    expect(text).toContain('(no detail supplied)');
+    expect(text).not.toContain('undefined');
+  });
+
   it('still reports a genuinely failed WRITE as an error', async () => {
     // The guard must not swallow a real failure: here the update itself fails.
     vi.mocked(lib.runOrDiagnose).mockResolvedValue(errorResult('Google API error (404 notFound)'));