gogcli-mcp-gmail 2.25.0 → 2.27.0

package/dist/index.js

@@ -31000,9 +31000,87 @@ var StdioServerTransport = class {
   }
 };
 
+// ../../node_modules/@chrischall/mcp-utils/dist/errors/index.js
+var McpToolError = class extends Error {
+  /** Actionable remediation text, when one applies. */
+  hint;
+  constructor(message, opts) {
+    super(message, opts?.cause !== void 0 ? { cause: opts.cause } : void 0);
+    this.name = "McpToolError";
+    if (opts?.hint !== void 0)
+      this.hint = opts.hint;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var BEARER_RE = /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
+var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{8,}\b/g;
+var BASIC_AUTH_RE = /(authorization\s*:\s*basic\s+)[A-Za-z0-9+/=_-]{6,}/gi;
+var SET_COOKIE_RE = /(\bset-cookie\s*:\s*)([^=;,\s]+)=[^;,\s]*/gi;
+var COOKIE_HEADER_RE = /((?<!set-)\bcookie\s*:\s*)((?:[^=;,\s]+=[^;,\s]*)(?:;\s*[^=;,\s]+=[^;,\s]*)*)/gi;
+var API_KEY_RE = new RegExp([
+  "sk-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])",
+  // OpenAI / Anthropic (incl. sk-ant-…)
+  "gh[pousr]_[A-Za-z0-9]{36,}\\b",
+  // GitHub ghp_/gho_/ghu_/ghs_/ghr_
+  "xox[baprs]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])",
+  // Slack
+  "AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])",
+  // Google API key (39 chars total)
+  "AKIA[0-9A-Z]{16}\\b",
+  // AWS access key id (20 chars total)
+  "whsec_[A-Za-z0-9]{16,}\\b"
+  // webhook signing secret (Stripe-style)
+].map((p) => `\\b${p}`).join("|"), "g");
+var QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
+var AWS_SIGV4_RE = /([?&]X-Amz-(?:Signature|Security-Token|Credential)=)[^&#\s"'<>`]+/gi;
+var JSON_SECRET_KEYS = "access_token|refresh_token|client_secret|api_?key|password|passwd|secret|token";
+var JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")[^"]*(")`, "gi");
+var JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')[^']*(')`, "gi");
+function redactSecrets(text) {
+  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(AWS_SIGV4_RE, "$1[REDACTED]").replace(JSON_SECRET_DQ_RE, "$1[REDACTED]$2").replace(JSON_SECRET_SQ_RE, "$1[REDACTED]$2").replace(JWT_RE, "[REDACTED]");
+}
+
+// ../../node_modules/@chrischall/mcp-utils/dist/response/index.js
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function rawTextResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: redactSecrets(message) }],
+    isError: true
+  };
+}
+
 // ../../node_modules/@chrischall/mcp-utils/dist/server/index.js
+function hintResultOrRethrow(err) {
+  if (err instanceof McpToolError && err.hint) {
+    return errorResult(`${err.message}
+
+Hint: ${err.hint}`);
+  }
+  throw err;
+}
+function surfaceToolHints(server) {
+  const register = server.registerTool.bind(server);
+  server.registerTool = (name, config2, cb) => register(name, config2, (...args) => {
+    let result;
+    try {
+      result = cb(...args);
+    } catch (err) {
+      return hintResultOrRethrow(err);
+    }
+    return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
+  });
+}
 async function createMcpServer(opts) {
   const server = new McpServer({ name: opts.name, version: opts.version });
+  if (opts.surfaceHints !== false)
+    surfaceToolHints(server);
   if (opts.banner !== void 0) {
     console.error(opts.banner);
   }
@@ -31047,51 +31125,6 @@ async function runMcp(opts) {
   return server;
 }
 
-// ../../node_modules/@chrischall/mcp-utils/dist/errors/index.js
-var BEARER_RE = /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
-var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{8,}\b/g;
-var BASIC_AUTH_RE = /(authorization\s*:\s*basic\s+)[A-Za-z0-9+/=_-]{6,}/gi;
-var SET_COOKIE_RE = /(\bset-cookie\s*:\s*)([^=;,\s]+)=[^;,\s]*/gi;
-var COOKIE_HEADER_RE = /((?<!set-)\bcookie\s*:\s*)((?:[^=;,\s]+=[^;,\s]*)(?:;\s*[^=;,\s]+=[^;,\s]*)*)/gi;
-var API_KEY_RE = new RegExp([
-  "sk-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])",
-  // OpenAI / Anthropic (incl. sk-ant-…)
-  "gh[pousr]_[A-Za-z0-9]{36,}\\b",
-  // GitHub ghp_/gho_/ghu_/ghs_/ghr_
-  "xox[baprs]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])",
-  // Slack
-  "AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])",
-  // Google API key (39 chars total)
-  "AKIA[0-9A-Z]{16}\\b",
-  // AWS access key id (20 chars total)
-  "whsec_[A-Za-z0-9]{16,}\\b"
-  // webhook signing secret (Stripe-style)
-].map((p) => `\\b${p}`).join("|"), "g");
-var QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
-var AWS_SIGV4_RE = /([?&]X-Amz-(?:Signature|Security-Token|Credential)=)[^&#\s"'<>`]+/gi;
-var JSON_SECRET_KEYS = "access_token|refresh_token|client_secret|api_?key|password|passwd|secret|token";
-var JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")[^"]*(")`, "gi");
-var JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')[^']*(')`, "gi");
-function redactSecrets(text) {
-  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(AWS_SIGV4_RE, "$1[REDACTED]").replace(JSON_SECRET_DQ_RE, "$1[REDACTED]$2").replace(JSON_SECRET_SQ_RE, "$1[REDACTED]$2").replace(JWT_RE, "[REDACTED]");
-}
-
-// ../../node_modules/@chrischall/mcp-utils/dist/response/index.js
-function textResult(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-  };
-}
-function rawTextResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function errorResult(message) {
-  return {
-    content: [{ type: "text", text: redactSecrets(message) }],
-    isError: true
-  };
-}
-
 // ../../node_modules/@chrischall/mcp-utils/dist/config/index.js
 var PLACEHOLDER_RE = /^\$\{[^}]*\}$/;
 function readEnvVar(key, opts = {}) {
@@ -31776,6 +31809,13 @@ function formatAuthHealth(raw, now) {
   }
   return accounts.map((a) => formatOneAccountHealth(a, now)).join("\n\n");
 }
+function assertNotBoth(inlineParam, fileParam, inlineValue, fileValue) {
+  if (inlineValue !== void 0 && fileValue !== void 0) {
+    throw new Error(
+      `${inlineParam} and ${fileParam} are mutually exclusive \u2014 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.`
+    );
+  }
+}
 
 // ../gogcli-mcp/src/tools/auth.ts
 function registerAuthToolsWith(server, defaultServices) {
@@ -31908,6 +31948,95 @@ function authToolsFor(defaultServices) {
   return (server) => registerAuthToolsWith(server, defaultServices);
 }
 
+// ../gogcli-mcp/src/tools/calendar.ts
+var reminderParams = {
+  reminders: external_exports.array(external_exports.string()).max(5).optional().describe(
+    `Reminders as method:duration, e.g. ["popup:30m", "email:1d"]. Method is popup or email; duration accepts m/h/d (max 40320 minutes = 4 weeks). Google allows at most 5. These REPLACE the event's reminders \u2014 on update, pass an EMPTY array to drop custom reminders and go back to the calendar's defaults. Cannot be combined with noReminders.`
+  ),
+  noReminders: external_exports.boolean().optional().describe(
+    "Give the event no reminders at all, overriding the calendar's defaults. Different from an empty reminders array, which RESTORES those defaults. Cannot be combined with reminders."
+  )
+};
+
+// ../gogcli-mcp/src/attachments.ts
+var MAX_INLINE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+var RUNNER_MAX_BODY_BYTES = 32 * 1024 * 1024;
+var RUNNER_BODY_JSON_RESERVE_BYTES = 256 * 1024;
+var MAX_REQUEST_PAYLOAD_WIRE_BYTES = RUNNER_MAX_BODY_BYTES - RUNNER_BODY_JSON_RESERVE_BYTES;
+var MAX_INLINE_ATTACHMENT_TOTAL_BYTES = Math.floor(MAX_REQUEST_PAYLOAD_WIRE_BYTES * 3 / 4);
+function wireBytesOf(arg) {
+  if (typeof arg === "string") return Buffer.byteLength(arg, "utf8");
+  return arg.encoding === "base64" ? arg.contents.length : Buffer.byteLength(arg.contents, "utf8");
+}
+var formatMiB = (bytes) => `${Math.floor(bytes / (1024 * 1024))} MiB`;
+var INLINE_ATTACHMENT_LIMITS_TEXT = `up to ${formatMiB(MAX_INLINE_ATTACHMENT_BYTES)} per file and ${formatMiB(MAX_INLINE_ATTACHMENT_TOTAL_BYTES)} in total`;
+var inlineAttachmentSchema = external_exports.object({
+  filename: external_exports.string().min(1).describe(
+    `Filename the recipient will see, e.g. "pendant-layouts.png". gog infers the attachment's MIME type from this extension, so give it the right one \u2014 a .png sent as "layouts" arrives as an untyped blob. Must be a single filename, not a path.`
+  ),
+  contentBase64: external_exports.string().min(1).describe(
+    "The file's bytes, base64-encoded (standard alphabet, with padding). This is the whole point of this parameter: the bytes travel with the request, so nothing needs to exist on the gog server's filesystem."
+  )
+});
+var attachInlineParam = external_exports.array(inlineAttachmentSchema).optional().describe(
+  `Attachments supplied as BYTES rather than as server-side paths \u2014 use this whenever you hold a file and the gog server does not, which is always the case on the hosted connector and on any remote deployment. Each entry is {filename, contentBase64} (${INLINE_ATTACHMENT_LIMITS_TEXT}). Can be combined with \`attach\`: the two name disjoint files (paths read on the server vs. bytes sent with the call), and both end up as ordinary attachments on the message.`
+);
+function validateFilename(filename, where) {
+  if (/[/\\]/.test(filename)) {
+    throw new Error(
+      `${where}: filename ${JSON.stringify(filename)} must be a bare filename, not a path. Pass just the name the recipient should see, e.g. "report.pdf".`
+    );
+  }
+  if (/[\x00-\x1f]/.test(filename) || /^\.+$/.test(filename) || filename.length > 200) {
+    throw new Error(
+      `${where}: filename ${JSON.stringify(filename)} is not a usable filename (no control characters, not "."/"..", 200 characters max).`
+    );
+  }
+}
+function decodedLength(contentBase64) {
+  const buf = Buffer.from(contentBase64, "base64");
+  return buf.toString("base64") === contentBase64 ? buf.length : null;
+}
+function inlineFileArg(flag, attachment, opts = {}) {
+  const { filename, contentBase64 } = attachment;
+  const where = opts.where ?? `attachInline entry ${JSON.stringify(filename)}`;
+  validateFilename(filename, where);
+  const bytes = decodedLength(contentBase64);
+  if (bytes === null) {
+    throw new Error(
+      `${where}: contents are not valid base64. Send the standard alphabet with padding and no line breaks \u2014 the value must survive a decode/re-encode round trip unchanged.`
+    );
+  }
+  if (bytes > MAX_INLINE_ATTACHMENT_BYTES) {
+    throw new Error(
+      `${where}: ${bytes} bytes exceeds the ${MAX_INLINE_ATTACHMENT_BYTES}-byte (${formatMiB(MAX_INLINE_ATTACHMENT_BYTES)}) per-file limit for inline content. Upload it to Drive and link to it instead, or send it from a local (stdio) deployment using a real server-side path.`
+    );
+  }
+  const arg = { kind: "file", flag, contents: contentBase64, encoding: "base64", filename };
+  if (opts.positional) arg.positional = true;
+  return { arg, bytes };
+}
+function inlineAttachmentArgs(flag, attachments, siblingArgs = []) {
+  if (!attachments?.length) return [];
+  const args = [];
+  const siblingWire = siblingArgs.reduce((sum, arg) => sum + wireBytesOf(arg), 0);
+  let attachmentWire = 0;
+  let decodedTotal = 0;
+  for (const attachment of attachments) {
+    const { arg, bytes } = inlineFileArg(flag, attachment);
+    attachmentWire += arg.contents.length;
+    decodedTotal += bytes;
+    if (siblingWire + attachmentWire > MAX_REQUEST_PAYLOAD_WIRE_BYTES) {
+      const blame = attachmentWire <= MAX_REQUEST_PAYLOAD_WIRE_BYTES ? ` These attachments would fit on their own; the rest of the message (its body, mostly) spends ${siblingWire} bytes of the same budget.` : "";
+      throw new Error(
+        `This message is too large to send: ${decodedTotal} bytes of attachments (${attachmentWire} bytes once base64-encoded for transit) exceed the ${MAX_REQUEST_PAYLOAD_WIRE_BYTES}-byte request limit.${blame} The ceiling for attachments alone is ${MAX_INLINE_ATTACHMENT_TOTAL_BYTES} bytes (${formatMiB(MAX_INLINE_ATTACHMENT_TOTAL_BYTES)}); a long body lowers it. Send fewer or smaller files per message, shorten the body, or upload the large files to Drive and link them.`
+      );
+    }
+    args.push(arg);
+  }
+  return args;
+}
+
 // ../gogcli-mcp/src/gmail-results.ts
 function sortKey(item) {
   for (const raw of [item.internalDateIso, item.date]) {
@@ -31967,6 +32096,7 @@ async function fetchGmailPages(runPage, itemsKey, maxPages, startToken) {
   const merged = [];
   let base;
   let token = startToken;
+  const fetched = new Set(startToken === void 0 ? [] : [startToken]);
   for (let pages = 0; pages < maxPages; pages++) {
     const result = await runPage(token);
     const parsed = parsePage(result, itemsKey);
@@ -31975,8 +32105,17 @@ async function fetchGmailPages(runPage, itemsKey, maxPages, startToken) {
     }
     base = parsed;
     merged.push(...parsed[itemsKey]);
-    token = typeof parsed.nextPageToken === "string" && parsed.nextPageToken !== "" ? parsed.nextPageToken : void 0;
-    if (token === void 0) break;
+    const next = typeof parsed.nextPageToken === "string" && parsed.nextPageToken !== "" ? parsed.nextPageToken : void 0;
+    if (next === void 0) {
+      token = void 0;
+      break;
+    }
+    if (fetched.has(next)) {
+      token = next;
+      break;
+    }
+    fetched.add(next);
+    token = next;
   }
   return finish(base, itemsKey, merged, token);
 }
@@ -32000,86 +32139,46 @@ function finish(base, itemsKey, merged, token) {
   return rawTextResult(JSON.stringify(out));
 }
 
-// ../gogcli-mcp/src/attachments.ts
-var MAX_INLINE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
-var RUNNER_MAX_BODY_BYTES = 32 * 1024 * 1024;
-var RUNNER_BODY_JSON_RESERVE_BYTES = 256 * 1024;
-var MAX_REQUEST_PAYLOAD_WIRE_BYTES = RUNNER_MAX_BODY_BYTES - RUNNER_BODY_JSON_RESERVE_BYTES;
-var MAX_INLINE_ATTACHMENT_TOTAL_BYTES = Math.floor(MAX_REQUEST_PAYLOAD_WIRE_BYTES * 3 / 4);
-function wireBytesOf(arg) {
-  if (typeof arg === "string") return Buffer.byteLength(arg, "utf8");
-  return arg.encoding === "base64" ? arg.contents.length : Buffer.byteLength(arg.contents, "utf8");
-}
-var formatMiB = (bytes) => `${Math.floor(bytes / (1024 * 1024))} MiB`;
-var INLINE_ATTACHMENT_LIMITS_TEXT = `up to ${formatMiB(MAX_INLINE_ATTACHMENT_BYTES)} per file and ${formatMiB(MAX_INLINE_ATTACHMENT_TOTAL_BYTES)} in total`;
-var inlineAttachmentSchema = external_exports.object({
-  filename: external_exports.string().min(1).describe(
-    `Filename the recipient will see, e.g. "pendant-layouts.png". gog infers the attachment's MIME type from this extension, so give it the right one \u2014 a .png sent as "layouts" arrives as an untyped blob. Must be a single filename, not a path.`
-  ),
-  contentBase64: external_exports.string().min(1).describe(
-    "The file's bytes, base64-encoded (standard alphabet, with padding). This is the whole point of this parameter: the bytes travel with the request, so nothing needs to exist on the gog server's filesystem."
-  )
-});
-var attachInlineParam = external_exports.array(inlineAttachmentSchema).optional().describe(
-  `Attachments supplied as BYTES rather than as server-side paths \u2014 use this whenever you hold a file and the gog server does not, which is always the case on the hosted connector and on any remote deployment. Each entry is {filename, contentBase64} (${INLINE_ATTACHMENT_LIMITS_TEXT}). Can be combined with \`attach\`: the two name disjoint files (paths read on the server vs. bytes sent with the call), and both end up as ordinary attachments on the message.`
-);
-function validateFilename(filename, where) {
-  if (/[/\\]/.test(filename)) {
-    throw new Error(
-      `${where}: filename ${JSON.stringify(filename)} must be a bare filename, not a path. Pass just the name the recipient should see, e.g. "report.pdf".`
-    );
-  }
-  if (/[\x00-\x1f]/.test(filename) || /^\.+$/.test(filename) || filename.length > 200) {
-    throw new Error(
-      `${where}: filename ${JSON.stringify(filename)} is not a usable filename (no control characters, not "."/"..", 200 characters max).`
-    );
-  }
-}
-function decodedLength(contentBase64) {
-  const buf = Buffer.from(contentBase64, "base64");
-  return buf.toString("base64") === contentBase64 ? buf.length : null;
-}
-function inlineFileArg(flag, attachment, opts = {}) {
-  const { filename, contentBase64 } = attachment;
-  const where = opts.where ?? `attachInline entry ${JSON.stringify(filename)}`;
-  validateFilename(filename, where);
-  const bytes = decodedLength(contentBase64);
-  if (bytes === null) {
-    throw new Error(
-      `${where}: contents are not valid base64. Send the standard alphabet with padding and no line breaks \u2014 the value must survive a decode/re-encode round trip unchanged.`
-    );
-  }
-  if (bytes > MAX_INLINE_ATTACHMENT_BYTES) {
-    throw new Error(
-      `${where}: ${bytes} bytes exceeds the ${MAX_INLINE_ATTACHMENT_BYTES}-byte (${formatMiB(MAX_INLINE_ATTACHMENT_BYTES)}) per-file limit for inline content. Upload it to Drive and link to it instead, or send it from a local (stdio) deployment using a real server-side path.`
-    );
-  }
-  const arg = { kind: "file", flag, contents: contentBase64, encoding: "base64", filename };
-  if (opts.positional) arg.positional = true;
-  return { arg, bytes };
-}
-function inlineAttachmentArgs(flag, attachments, siblingArgs = []) {
-  if (!attachments?.length) return [];
-  const args = [];
-  const siblingWire = siblingArgs.reduce((sum, arg) => sum + wireBytesOf(arg), 0);
-  let attachmentWire = 0;
-  let decodedTotal = 0;
-  for (const attachment of attachments) {
-    const { arg, bytes } = inlineFileArg(flag, attachment);
-    attachmentWire += arg.contents.length;
-    decodedTotal += bytes;
-    if (siblingWire + attachmentWire > MAX_REQUEST_PAYLOAD_WIRE_BYTES) {
-      const blame = attachmentWire <= MAX_REQUEST_PAYLOAD_WIRE_BYTES ? ` These attachments would fit on their own; the rest of the message (its body, mostly) spends ${siblingWire} bytes of the same budget.` : "";
-      throw new Error(
-        `This message is too large to send: ${decodedTotal} bytes of attachments (${attachmentWire} bytes once base64-encoded for transit) exceed the ${MAX_REQUEST_PAYLOAD_WIRE_BYTES}-byte request limit.${blame} The ceiling for attachments alone is ${MAX_INLINE_ATTACHMENT_TOTAL_BYTES} bytes (${formatMiB(MAX_INLINE_ATTACHMENT_TOTAL_BYTES)}); a long body lowers it. Send fewer or smaller files per message, shorten the body, or upload the large files to Drive and link them.`
-      );
-    }
-    args.push(arg);
-  }
-  return args;
-}
-
 // ../gogcli-mcp/src/tools/gmail.ts
+var replySchema = {
+  messageId: external_exports.string().describe("Gmail message ID to reply to \u2014 the short hex `id` from gog_gmail_get / _search (or gog_gmail_messages_search, gogcli-mcp-gmail only). NOT the threadId, NOT the RFC822 `<\u2026@host>` Message-Id header."),
+  body: external_exports.string().optional().describe("Reply body (plain text; required unless bodyHtml or bodyHtmlFile is set). Any size \u2014 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: external_exports.string().optional().describe("Reply body (HTML; optional). Pass the HTML itself at any size \u2014 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: external_exports.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 \u2014 supplying both is rejected. You rarely need this: bodyHtml handles large bodies on its own.`),
+  to: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to To (repeatable). Added on top of the recipients inherited from the original message."),
+  cc: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to Cc (repeatable)"),
+  bcc: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to Bcc (repeatable)"),
+  remove: external_exports.array(external_exports.string()).optional().describe("Remove these recipients from all fields (repeatable) \u2014 e.g. to drop someone from a reply-all."),
+  subject: external_exports.string().optional().describe('Override reply subject (default: "Re: <original>"). A changed subject starts a NEW Gmail thread.'),
+  noQuote: external_exports.boolean().optional().describe("Do not include the original message quoted below the reply (default: the original is quoted)"),
+  attach: external_exports.array(external_exports.string()).optional().describe(`File paths to attach (repeatable), resolved ON THE GOG SERVER's filesystem \u2014 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" \u2014 use attachInline there. Read on the server, base64-encoded with a MIME type inferred from the extension.`),
+  attachInline: attachInlineParam,
+  from: external_exports.string().optional().describe("Send from this email address (must be a verified send-as alias)"),
+  autoFromAddressedAlias: external_exports.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 \u2014 so a reply to mail sent to an alias goes back out from that alias. Ignored when from is set."),
+  signature: external_exports.boolean().optional().describe("Append the Gmail signature from the active send-as address"),
+  signatureFrom: external_exports.string().optional().describe("Append the Gmail signature from this send-as email address"),
+  signatureFile: external_exports.string().optional().describe("Append a local signature file (plain text or HTML), read on the gog server"),
+  account: accountParam
+};
+function appendReplyFlags(args, f) {
+  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}`);
+  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}`);
+  args.push(f.autoFromAddressedAlias ? "--auto-from-addressed-alias" : "--auto-from-addressed-alias=false");
+}
 function registerGmailTools(server) {
   server.registerTool("gog_gmail_search", {
     description: 'Search Gmail threads using Gmail query syntax (e.g. "from:alice subject:invoice is:unread"). The query is passed verbatim to Gmail; a bare name token (from:alison) matches per Gmail\'s own heuristics, a full address (from:alison@example.com) is exact. To match a contact across several addresses, OR them: from:(a@x.com OR b@y.com). Results are ALWAYS newest-first by Gmail\'s internalDate \u2014 the wrapper sorts them, so the first result is the most recent match and a recent message can never be buried below older ones. IMPORTANT \u2014 a response carrying "truncated": true is an INCOMPLETE view of the matches: NEVER report that a message does not exist, or that there is no such mail, on the strength of one. Page through it (pass nextPageToken back as `pageToken`), set maxPages to walk several pages in one call, or narrow the query, and only then draw a conclusion. If you already know the thread, do not search for it at all \u2014 read it directly with gog_gmail_thread_get, which returns the whole thread and cannot be truncated or mis-ranked.',
@@ -32132,7 +32231,7 @@ function registerGmailTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_gmail_send", {
-    description: 'Send an email. Two ways to attach a file: `attach` takes paths READ ON THE GOG SERVER, and `attachInline` takes the bytes themselves. Use attachInline unless you know the file exists on the same machine gog runs on \u2014 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 \u2014 check it to confirm the files were embedded.',
+    description: 'Send an email. Two ways to attach a file: `attach` takes paths READ ON THE GOG SERVER, and `attachInline` takes the bytes themselves. Use attachInline unless you know the file exists on the same machine gog runs on \u2014 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 \u2014 check it to confirm the files were embedded. NOT the tool for answering a message: replyToMessageId only files this in the right thread \u2014 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: external_exports.string().describe("Recipient(s), comma-separated"),
@@ -32140,23 +32239,43 @@ function registerGmailTools(server) {
       body: external_exports.string().describe("Email body (plain text). Any size \u2014 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: external_exports.string().optional().describe("CC recipients, comma-separated"),
       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"),
+      replyToMessageId: external_exports.string().optional().describe('Message ID to thread this message against \u2014 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: external_exports.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: external_exports.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: external_exports.array(external_exports.string()).optional().describe(`File paths to attach (repeatable), resolved ON THE GOG SERVER's filesystem \u2014 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" \u2014 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 }) => {
     const args = ["gmail", "send", `--to=${to}`, `--subject=${subject}`, payloadArg("body", "body-file", 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 (quote) args.push("--quote");
     if (attach) for (const path of attach) args.push(`--attach=${path}`);
     const inline = inlineAttachmentArgs("attach", attachInline, args);
     args.push(...inline);
     return runOrDiagnose(args, { account });
   });
+  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 \u2014 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 = ["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 = ["gmail", "reply-all", messageId];
+    appendReplyFlags(args, flags);
+    return runOrDiagnose(args, { account });
+  });
   registerRunTool(server, { service: "gmail", examples: '"archive", "mark-read", "labels"' });
 }
 
@@ -32170,7 +32289,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.25.0" : "0.0.0";
+var VERSION = true ? "2.27.0" : "0.0.0";
 
 // ../gogcli-mcp/src/auth-log.ts
 var FAILURES = /* @__PURE__ */ new Set([
@@ -32657,13 +32776,6 @@ function useRemoteGogRunner(env = process.env) {
 }
 
 // src/tools/gmail-extra.ts
-function assertNotBoth(inlineParam, fileParam, inlineValue, fileValue) {
-  if (inlineValue !== void 0 && fileValue !== void 0) {
-    throw new Error(
-      `${inlineParam} and ${fileParam} are mutually exclusive \u2014 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.`
-    );
-  }
-}
 function resultText(result) {
   const first = result.content[0];
   return first?.type === "text" ? first.text : void 0;
@@ -34139,7 +34251,7 @@ function registerExtraGmailTools(server) {
     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 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)"),
+    quote: external_exports.boolean().optional().describe('Include the original message quoted below the body. Requires replyToMessageId or replyToThreadId. DEFAULTS OFF: a draft created with a reply target but without this threads correctly and still reads as a brand-new message, because gog only quotes by default on its reply subcommands. For a real reply draft prefer gog_gmail_drafts_reply / gog_gmail_drafts_reply_all, which also inherit the recipients and the "Re:" subject that this tool leaves to you.'),
     replyAll: external_exports.boolean().optional().describe("Auto-populate recipients from the original message (reply-all), inferring To/Cc from it. Requires replyToMessageId or replyToThreadId. Explicit to/cc/bcc still apply on top; omitRecipients still suppresses them."),
     attach: external_exports.array(external_exports.string()).optional().describe(`File paths to attach (repeatable), resolved ON THE GOG SERVER's filesystem \u2014 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" \u2014 use attachInline there. Read on the server, base64-encoded with a MIME type inferred from the extension. The JSON result echoes attached filenames and byte sizes \u2014 check it to confirm the files were found and embedded. On gog_gmail_drafts_update, supplying attach REPLACES the draft's existing attachments; omitting it preserves them (use clearAttachments to remove all).`),
     attachInline: attachInlineParam,
@@ -34327,63 +34439,6 @@ function registerExtraGmailTools(server) {
     if (skipAttachments) args.push("--skip-attachments");
     return runOrDiagnose(args, { account });
   });
-  const replySchema = {
-    messageId: external_exports.string().describe("Gmail message ID to reply to \u2014 the short hex `id` from gog_gmail_get / _search / _messages_search (NOT the threadId, NOT the RFC822 `<\u2026@host>` Message-Id header)."),
-    body: external_exports.string().optional().describe("Reply body (plain text; required unless bodyHtml or bodyHtmlFile is set). Any size \u2014 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: external_exports.string().optional().describe("Reply body (HTML; optional). Pass the HTML itself at any size \u2014 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: external_exports.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 \u2014 supplying both is rejected. You rarely need this: bodyHtml handles large bodies on its own.`),
-    to: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to To (repeatable). Added on top of the recipients inherited from the original message."),
-    cc: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to Cc (repeatable)"),
-    bcc: external_exports.array(external_exports.string()).optional().describe("Add or move recipients to Bcc (repeatable)"),
-    remove: external_exports.array(external_exports.string()).optional().describe("Remove these recipients from all fields (repeatable) \u2014 e.g. to drop someone from a reply-all."),
-    subject: external_exports.string().optional().describe('Override reply subject (default: "Re: <original>"). A changed subject starts a NEW Gmail thread.'),
-    noQuote: external_exports.boolean().optional().describe("Do not include the original message quoted below the reply (default: the original is quoted)"),
-    attach: external_exports.array(external_exports.string()).optional().describe(`File paths to attach (repeatable), resolved ON THE GOG SERVER's filesystem \u2014 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" \u2014 use attachInline there. Read on the server, base64-encoded with a MIME type inferred from the extension.`),
-    attachInline: attachInlineParam,
-    from: external_exports.string().optional().describe("Send from this email address (must be a verified send-as alias)"),
-    autoFromAddressedAlias: external_exports.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 \u2014 so a reply to mail sent to an alias goes back out from that alias. Ignored when from is set."),
-    signature: external_exports.boolean().optional().describe("Append the Gmail signature from the active send-as address"),
-    signatureFrom: external_exports.string().optional().describe("Append the Gmail signature from this send-as email address"),
-    signatureFile: external_exports.string().optional().describe("Append a local signature file (plain text or HTML), read on the gog server"),
-    account: accountParam
-  };
-  function appendReplyFlags(args, f) {
-    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}`);
-    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}`);
-    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 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 }) => {
-    const args = ["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 (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 }) => {
-    const args = ["gmail", "reply-all", messageId];
-    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.",

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.25.0",
+  "version": "2.27.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/mint.yaml

@@ -0,0 +1,107 @@
+version: 1
+name: Google Gmail (gogcli)
+slug: gogcli-mcp-gmail
+summary: >-
+  Extended Gmail MCP server via gogcli — auth + full Gmail support (threads,
+  labels, drafts, attachments, forward, autoreply, bulk operations)
+command:
+  # This package publishes a single bin; naming it keeps the install
+  # unambiguous alongside its eight sibling packages.
+  bin: gogcli-mcp-gmail
+env:
+  - name: GOG_CLIENT_ID
+    required: false
+    help: >-
+      Google OAuth client id. NOTE: on the local-spawn path the child `gog`
+      receives a sanitized env — runner.ts drops GOG_ACCESS_TOKEN and every
+      *_TOKEN / *_SECRET / *_API_KEY / *_PRIVATE_KEY variable — so the CLI
+      authenticates from its own stored credentials under $HOME (see
+      state.dataDir), not from these variables being passed through.
+  - name: GOG_CLIENT_SECRET
+    secret: true
+    required: false
+    help: >-
+      Google OAuth client secret. Stripped from the spawned CLI's environment
+      by runner.ts's *_SECRET rule — see GOG_CLIENT_ID.
+  - name: GOG_REFRESH_TOKEN
+    secret: true
+    required: false
+    help: >-
+      Google OAuth refresh token. Stripped from the spawned CLI's environment
+      by runner.ts's *_TOKEN rule — see GOG_CLIENT_ID. A hosted deployment must
+      therefore carry gog's authorised-account state in its persisted data dir,
+      or drive a remote runner via GOG_RUNNER_URL.
+  - name: GOG_ACCESS_TOKEN
+    secret: true
+    required: false
+    help: >-
+      Deliberately removed from the spawned CLI's environment by runner.ts, so
+      that a stale directly-passed token cannot shadow gog's stored refresh
+      credential. Leave unset.
+  - name: GOG_ACCOUNT
+    required: false
+    help: >-
+      Which configured Google account to act as, when more than one is
+      authorised. Defaults to the single/most recent account.
+  - name: GOG_READONLY
+    required: false
+    help: >-
+      Set to 1 to refuse every mutating operation. Recommended when the
+      connector is shared or you only need reads.
+  - name: GOG_PATH
+    required: false
+    help: >-
+      Path to the `gog` binary. Leave unset when the dependency below supplies
+      it; set it only to point at a binary you manage yourself.
+  - name: GOG_RUNNER_URL
+    required: false
+    help: >-
+      URL of a remote gog runner to execute against instead of spawning the
+      local binary. If you set this, add its host to egress.allow.
+  - name: GOG_RUNNER_KEY
+    secret: true
+    required: false
+    help: >-
+      Shared key authenticating calls to GOG_RUNNER_URL. Required whenever that
+      is set.
+  - name: GOG_TIMEZONE
+    required: false
+    help: >-
+      The IANA zone gog itself formats its naive timestamps in. The wrapper
+      reads it (naiveSourceTimeZone) to re-attach the correct offset, so it
+      should match gog's own configuration. Falls back to DISPLAY_TZ, then to
+      America/New_York.
+  - name: DISPLAY_TZ
+    required: false
+    help: >-
+      The IANA zone every rendered *Display field uses (displayTimeZone,
+      default America/New_York). It does not read GOG_TIMEZONE — the fallback
+      runs the other way, so this is also what GOG_TIMEZONE falls back to. An
+      invalid value degrades to the default rather than throwing.
+dependencies:
+  # Every tool shells out to the `gog` CLI; without it the server starts and
+  # then fails on the first call. This tag must track
+  # packages/gogcli-mcp/src/runner.ts's MIN_GOG_VERSION (the floor the tools
+  # assume) and the fly-gog-runner/Dockerfile GOG_VERSION build arg. See
+  # CLAUDE.md "Required gog version" — bumping the floor means bumping these
+  # nine pins too.
+  - kind: github-release
+    repo: openclaw/gogcli
+    tag: v0.38.1
+    asset: "gogcli_*_linux_amd64.tar.gz"
+    bin: [gog]
+state:
+  dataDir: true
+  reason: >-
+    `gog` keeps its authorised-account state and token cache under $HOME.
+    Without a persistent data dir every cold start has no account configured and
+    every tool call fails until the credentials are re-supplied.
+egress:
+  allow:
+    # Google OAuth token exchange and the Google REST APIs the CLI calls.
+    - oauth2.googleapis.com
+    - www.googleapis.com
+    - googleapis.com
+    #
+    # NOTE: if you set GOG_RUNNER_URL to run against a remote gog runner, add
+    # that host here too — it is supplied at runtime and cannot be declared.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-gmail",
-  "version": "2.25.0",
+  "version": "2.27.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>",
@@ -24,7 +24,7 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^0.14.0",
+    "@chrischall/mcp-utils": "^0.15.0",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.4.3"
   },

package/src/tools/gmail-extra.ts

@@ -2,29 +2,9 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { rawTextResult, textResult, errorResult } from '@chrischall/mcp-utils';
-import { accountParam, runOrDiagnose, run, diagnose, payloadArg, runExecutor, normalizeTimestamps, finalizeGmailSearch, fetchGmailPages, pageTokenParam, pageAliasParam, resolvePageToken, attachInlineParam, inlineAttachmentArgs} from '../../../gogcli-mcp/src/lib.js';
+import { accountParam, runOrDiagnose, run, diagnose, payloadArg, runExecutor, normalizeTimestamps, finalizeGmailSearch, fetchGmailPages, pageTokenParam, pageAliasParam, resolvePageToken, attachInlineParam, inlineAttachmentArgs, assertNotBoth, replySchema, appendReplyFlags} from '../../../gogcli-mcp/src/lib.js';
 import type { GogArg, InlineAttachmentInput } from '../../../gogcli-mcp/src/lib.js';
 
-// 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.
-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.`,
-    );
-  }
-}
-
 // Pull the text out of a single-text-block tool result; undefined for any
 // other shape (an error result is still a text block, so it parses below).
 function resultText(result: CallToolResult): string | undefined {
@@ -2889,7 +2869,7 @@ export function registerExtraGmailTools(server: McpServer): void {
     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 — 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)'),
+    quote: z.boolean().optional().describe('Include the original message quoted below the body. Requires replyToMessageId or replyToThreadId. DEFAULTS OFF: a draft created with a reply target but without this threads correctly and still reads as a brand-new message, because gog only quotes by default on its reply subcommands. For a real reply draft prefer gog_gmail_drafts_reply / gog_gmail_drafts_reply_all, which also inherit the recipients and the "Re:" subject that this tool leaves to you.'),
     replyAll: z.boolean().optional().describe('Auto-populate recipients from the original message (reply-all), inferring To/Cc from it. Requires replyToMessageId or replyToThreadId. Explicit to/cc/bcc still apply on top; omitRecipients still suppresses them.'),
     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. The JSON result echoes attached filenames and byte sizes — check it to confirm the files were found and embedded. On gog_gmail_drafts_update, supplying attach REPLACES the draft\'s existing attachments; omitting it preserves them (use clearAttachments to remove all).'),
     attachInline: attachInlineParam,
@@ -3216,97 +3196,11 @@ export function registerExtraGmailTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
-  // 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.
-  const replySchema = {
-    messageId: z.string().describe('Gmail message ID to reply to — the short hex `id` from gog_gmail_get / _search / _messages_search (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,
-  };
-
-  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;
-  };
-
-  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}`);
-    args.push(...inlineAttachmentArgs('attach', f.attachInline, args)); // see appendDraftFlags
-    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}`);
-    args.push(f.autoFromAddressedAlias ? '--auto-from-addressed-alias' : '--auto-from-addressed-alias=false'); // PINNED — see appendDraftFlags
-  }
-
-  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 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 }) => {
-    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 (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 }) => {
-    const args: GogArg[] = ['gmail', 'reply-all', messageId];
-    appendReplyFlags(args, flags);
-    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.
+  // path with them, so replySchema/appendReplyFlags are imported from the base
+  // package (where gog_gmail_reply itself now lives) 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

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

@@ -1742,96 +1742,6 @@ describe('gog_gmail_forward', () => {
   });
 });
 
-describe('gog_gmail_reply', () => {
-  it('calls runOrDiagnose with messageId and --body', async () => {
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Thanks' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Thanks', '--auto-from-addressed-alias=false'],
-      { account: undefined },
-    );
-  });
-
-  it('passes all reply flags including repeatable recipients', async () => {
-    await harness.callTool('gog_gmail_reply', {
-      messageId: 'm1',
-      body: 'Hi',
-      bodyHtml: '<p>Hi</p>',
-      to: ['a@b.com', 'c@d.com'],
-      cc: ['cc@x.com'],
-      bcc: ['bcc@x.com'],
-      remove: ['old@x.com'],
-      subject: 'New subject',
-      noQuote: true,
-      attach: ['/tmp/a.pdf', '/tmp/b.pdf'],
-      from: 'me@x.com',
-      signature: true,
-      signatureFrom: 'alias@x.com',
-      signatureFile: '/tmp/sig.txt',
-      account: 'me@gmail.com',
-    });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      [
-        'gmail', 'reply', 'm1',
-        '--body=Hi',
-        '--body-html=<p>Hi</p>',
-        '--to=a@b.com',
-        '--to=c@d.com',
-        '--cc=cc@x.com',
-        '--bcc=bcc@x.com',
-        '--remove=old@x.com',
-        '--subject=New subject',
-        '--no-quote',
-        '--attach=/tmp/a.pdf',
-        '--attach=/tmp/b.pdf',
-        '--from=me@x.com',
-        '--signature',
-        '--signature-from=alias@x.com',
-        '--signature-file=/tmp/sig.txt', '--auto-from-addressed-alias=false'
-      ],
-      { account: 'me@gmail.com' },
-    );
-  });
-
-  it('omits --no-quote and --signature when false', async () => {
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', noQuote: false, signature: false });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false'],
-      { account: undefined },
-    );
-  });
-});
-
-describe('gog_gmail_reply_all', () => {
-  it('uses the reply-all subcommand', async () => {
-    await harness.callTool('gog_gmail_reply_all', { messageId: 'm1', body: 'Thanks all' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply-all', 'm1', '--body=Thanks all', '--auto-from-addressed-alias=false'],
-      { account: undefined },
-    );
-  });
-
-  it('passes repeatable recipient and signature flags', async () => {
-    await harness.callTool('gog_gmail_reply_all', {
-      messageId: 'm1',
-      bodyHtml: '<p>Hi</p>',
-      cc: ['x@y.com', 'z@y.com'],
-      remove: ['drop@y.com'],
-      signatureFile: '/tmp/sig.html',
-    });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      [
-        'gmail', 'reply-all', 'm1',
-        '--body-html=<p>Hi</p>',
-        '--cc=x@y.com',
-        '--cc=z@y.com',
-        '--remove=drop@y.com',
-        '--signature-file=/tmp/sig.html', '--auto-from-addressed-alias=false'
-      ],
-      { account: undefined },
-    );
-  });
-});
-
 // 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
@@ -2524,24 +2434,6 @@ describe('large payloads route to file args', () => {
     expect(args()).not.toContain('--thread-id=t1');
   });
 
-  it('gog_gmail_reply routes a large body and bodyHtml to file args', async () => {
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: big, bodyHtml: bigHtml });
-    expect(args()).toEqual([
-      'gmail', 'reply', 'm1',
-      { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
-      { kind: 'file', flag: 'body-html-file', contents: bigHtml, ext: 'html' }, '--auto-from-addressed-alias=false'
-    ]);
-  });
-
-  it('gog_gmail_reply_all routes a large body to --body-file, leaving the signature boolean a bare flag', async () => {
-    await harness.callTool('gog_gmail_reply_all', { messageId: 'm1', body: big, signature: true });
-    expect(args()).toEqual([
-      'gmail', 'reply-all', 'm1',
-      { kind: 'file', flag: 'body-file', contents: big, ext: undefined },
-      '--signature', '--auto-from-addressed-alias=false'
-    ]);
-  });
-
   it('gog_gmail_forward routes a large note to --note-file', async () => {
     await harness.callTool('gog_gmail_forward', { messageId: 'm1', to: 'a@b.com', note: big });
     expect(args()).toEqual([
@@ -2587,33 +2479,6 @@ describe('inline/file param conflicts are rejected before gog runs', () => {
     expect((res.content[0] as { text: string }).text).toContain('mutually exclusive');
     expect(lib.runOrDiagnose).not.toHaveBeenCalled();
   });
-
-  it('gog_gmail_reply rejects bodyHtml plus bodyHtmlFile', async () => {
-    const res = await harness.callTool('gog_gmail_reply', {
-      messageId: 'm1', bodyHtml: '<p>Hi</p>', bodyHtmlFile: '/tmp/b.html',
-    });
-    expect(res.isError).toBe(true);
-    expect((res.content[0] as { text: string }).text).toContain('bodyHtml and bodyHtmlFile are mutually exclusive');
-    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
-  });
-
-  it('an empty-string bodyHtml still counts as supplied and conflicts', async () => {
-    // Guards the `!== undefined` check against a falsy-but-present value
-    // sliding through to gog, which rejects the pair regardless of content.
-    const res = await harness.callTool('gog_gmail_reply', {
-      messageId: 'm1', body: 'B', bodyHtml: '', bodyHtmlFile: '/tmp/b.html',
-    });
-    expect(res.isError).toBe(true);
-    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
-  });
-
-  it('bodyHtmlFile alone still passes through as --body-html-file', async () => {
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', bodyHtmlFile: '/tmp/b.html' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['gmail', 'reply', 'm1', '--body=Hi', '--body-html-file=/tmp/b.html', '--auto-from-addressed-alias=false'],
-      { account: undefined },
-    );
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -2808,15 +2673,6 @@ describe('gog 0.35.0 — --auto-from-addressed-alias is pinned on every send-sha
     await harness.callTool('gog_gmail_drafts_update', { draftId: 'd1', subject: 'S', body: 'B', autoFromAddressedAlias: true });
     expect(args()).toEqual(['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--auto-from-addressed-alias']);
   });
-
-  it('gog_gmail_reply and gog_gmail_reply_all pin it', async () => {
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi' });
-    expect(args()).toEqual(['gmail', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false']);
-    vi.clearAllMocks();
-    vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
-    await harness.callTool('gog_gmail_reply_all', { messageId: 'm1', body: 'Hi', autoFromAddressedAlias: true });
-    expect(args()).toEqual(['gmail', 'reply-all', 'm1', '--body=Hi', '--auto-from-addressed-alias']);
-  });
 });
 
 describe('gog 0.35.0 — gog_gmail_import', () => {
@@ -2871,8 +2727,6 @@ describe('server-side file params never advertise stdin as usable', () => {
     ['gog_gmail_import', 'file'],
     ['gog_gmail_drafts_create', 'bodyHtmlFile'],
     ['gog_gmail_drafts_update', 'bodyHtmlFile'],
-    ['gog_gmail_reply', 'bodyHtmlFile'],
-    ['gog_gmail_reply_all', 'bodyHtmlFile'],
   ];
 
   async function paramDescriptions(): Promise<Map<string, Record<string, { description?: string }>>> {