gogcli-mcp-gmail 2.18.3 → 2.18.4

package/dist/index.js

@@ -31280,6 +31280,198 @@ async function run(args, options = {}) {
   }
 }
 
+// ../gogcli-mcp/src/timestamps.ts
+var DEFAULT_DISPLAY_TZ = "America/New_York";
+function isValidTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function displayTimeZone() {
+  const configured = readEnvVar("DISPLAY_TZ");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return DEFAULT_DISPLAY_TZ;
+}
+function naiveSourceTimeZone() {
+  const configured = readEnvVar("GOG_TIMEZONE");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return displayTimeZone();
+}
+function offsetAt(instant, tz) {
+  const w = wallPartsIn(instant, tz);
+  const asUTC = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second, instant.getUTCMilliseconds());
+  const minutes = Math.round((asUTC - instant.getTime()) / 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  const abs = Math.abs(minutes);
+  return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+function wallPartsIn(instant, tz) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    // h23 pins midnight to hour 00; without it some ICU builds render hour 24.
+    hourCycle: "h23"
+  }).formatToParts(instant);
+  const out = {};
+  for (const p of parts) {
+    if (p.type !== "literal") out[p.type] = Number(p.value);
+  }
+  return out;
+}
+function wallTimeToInstant(y, mo, d, h, mi, s, ms, tz) {
+  let guess = Date.UTC(y, mo - 1, d, h, mi, s, ms);
+  for (let i = 0; i < 2; i += 1) {
+    const seen = wallPartsIn(new Date(guess), tz);
+    const seenUTC = Date.UTC(seen.year, seen.month - 1, seen.day, seen.hour, seen.minute, seen.second, ms);
+    const drift = Date.UTC(y, mo - 1, d, h, mi, s, ms) - seenUTC;
+    if (drift === 0) break;
+    guess += drift;
+  }
+  return new Date(guess);
+}
+function pad(n, width = 2) {
+  return String(n).padStart(width, "0");
+}
+function isoWithOffset(instant, tz, offset) {
+  const w = wallPartsIn(instant, tz);
+  const msPart = instant.getUTCMilliseconds();
+  const frac = msPart ? `.${pad(msPart, 3)}` : "";
+  return `${pad(w.year, 4)}-${pad(w.month)}-${pad(w.day)}T${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}${frac}${offset}`;
+}
+function formatInstant(instant, tz = displayTimeZone()) {
+  const offset = offsetAt(instant, tz);
+  const display = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short"
+  }).format(instant);
+  return { iso: isoWithOffset(instant, tz, offset), display };
+}
+var TIMESTAMP_KEYS = /* @__PURE__ */ new Set([
+  "date",
+  // gog gmail message/thread listings ("2026-07-28 03:36")
+  "dateTime",
+  // Calendar event start/end
+  "internalDate",
+  // Gmail, epoch milliseconds (authoritative)
+  "modifiedTime",
+  // Drive
+  "createdTime",
+  // Drive
+  "createTime",
+  "updateTime",
+  "updated",
+  "originalStartTime",
+  "expirationTime",
+  "lastModified",
+  "sentAt",
+  "viewedAt",
+  "modifiedAt",
+  "fetchedBodyAt",
+  "asOf"
+]);
+var ZONE_NAME_KEYS = /* @__PURE__ */ new Set(["timeZone", "timezone"]);
+var RFC3339_WITH_OFFSET = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?(Z|[+-]\d{2}:?\d{2})$/;
+var NAIVE_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?$/;
+var EPOCH_MILLIS = /^\d{13}$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function isRealCalendarDate(p) {
+  const utc = new Date(Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second));
+  return utc.getUTCFullYear() === p.year && utc.getUTCMonth() === p.month - 1 && utc.getUTCDate() === p.day && utc.getUTCHours() === p.hour && utc.getUTCMinutes() === p.minute && utc.getUTCSeconds() === p.second;
+}
+function parseTimestampValue(key, value, assumeNaiveIn) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "" || DATE_ONLY.test(raw)) return null;
+  if (key === "internalDate" && EPOCH_MILLIS.test(raw)) {
+    return new Date(Number(raw));
+  }
+  if (RFC3339_WITH_OFFSET.test(raw)) {
+    const parsed = new Date(raw.replace(" ", "T"));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const naive = NAIVE_DATE_TIME.exec(raw);
+  if (naive) {
+    const [, y, mo, d, h, mi, s, frac] = naive;
+    const ms = frac ? Number(frac.padEnd(3, "0").slice(0, 3)) : 0;
+    const parts = {
+      year: Number(y),
+      month: Number(mo),
+      day: Number(d),
+      hour: Number(h),
+      minute: Number(mi),
+      second: Number(s ?? "0")
+    };
+    if (!isRealCalendarDate(parts)) return null;
+    return wallTimeToInstant(
+      parts.year,
+      parts.month,
+      parts.day,
+      parts.hour,
+      parts.minute,
+      parts.second,
+      ms,
+      assumeNaiveIn
+    );
+  }
+  return null;
+}
+function walk(node, tz, naiveTz) {
+  let changed = false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (walk(item, tz, naiveTz)) changed = true;
+    }
+    return changed;
+  }
+  if (node === null || typeof node !== "object") return false;
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      if (walk(value, tz, naiveTz)) changed = true;
+      continue;
+    }
+    if (ZONE_NAME_KEYS.has(key) || !TIMESTAMP_KEYS.has(key)) continue;
+    const instant = parseTimestampValue(key, value, naiveTz);
+    if (!instant) continue;
+    const { iso, display } = formatInstant(instant, tz);
+    obj[key] = iso;
+    obj[`${key}Display`] = display;
+    changed = true;
+  }
+  return changed;
+}
+function detectIndent(text) {
+  const match = /\n(\s+)\S/.exec(text);
+  return match ? match[1].replace(/\t/g, "  ").length : 0;
+}
+function normalizeTimestamps(text, tz = displayTimeZone(), naiveTz = naiveSourceTimeZone()) {
+  const trimmed = text.trim();
+  if (trimmed === "" || !/^[[{]/.test(trimmed)) return text;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return text;
+  }
+  if (!walk(parsed, tz, naiveTz)) return text;
+  return JSON.stringify(parsed, null, detectIndent(text));
+}
+
 // ../gogcli-mcp/src/tools/utils.ts
 var PAYLOAD_INLINE_MAX = 4096;
 function payloadArg(inlineFlag, fileFlag, value, ext) {
@@ -31380,7 +31572,8 @@ ${accounts || "(none)"}${hint}`);
 }
 async function runOrDiagnose(args, options) {
   try {
-    return rawTextResult(await run(args, options));
+    const raw = await run(args, options);
+    return rawTextResult(options.lossless ? raw : normalizeTimestamps(raw));
   } catch (err) {
     return diagnose(err);
   }
@@ -31617,7 +31810,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.18.3" : "0.0.0";
+var VERSION = true ? "2.18.4" : "0.0.0";
 
 // src/tools/gmail-extra.ts
 function assertNotBoth(inlineParam, fileParam, inlineValue, fileValue) {
@@ -31790,7 +31983,7 @@ function registerExtraGmailTools(server) {
     const args = ["gmail", "raw", messageId];
     if (format) args.push(`--format=${format}`);
     if (pretty) args.push("--pretty");
-    return runOrDiagnose(args, { account });
+    return runOrDiagnose(args, { account, lossless: true });
   });
   server.registerTool("gog_gmail_attachment", {
     description: `Download a Gmail attachment and deliver its contents so you can actually read them. The real filename and MIME type are resolved from the message part metadata, so the saved file and response are named correctly (e.g. Guest_Copy.pdf), never a generic *.bin. deliver="auto" (default) is transport-aware: images always come back as a native image block; anything else is delivered by the channel that works on your transport \u2014 a readable server-side file PATH on local (stdio) clients that share the filesystem, or a Google Drive link on the remote connector (whose backend filesystem you can't read, and which rejects inline PDF/binary blobs). deliver="inline" forces the bytes inline as an image or embedded resource blob (use only if your client consumes resource blobs; errors if over gog's 3 MiB cap). deliver="drive" always uploads to Drive; deliver="off" writes the file server-side and returns {path, fileName, mimeType, bytes}. Drive delivery creates a file in your Drive (blocked when GOG_READONLY is set).`,

package/manifest.json

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

@@ -327,7 +327,8 @@ export function registerExtraGmailTools(server: McpServer): void {
     const args = ['gmail', 'raw', messageId];
     if (format) args.push(`--format=${format}`);
     if (pretty) args.push('--pretty');
-    return runOrDiagnose(args, { account });
+    // Verbatim by contract: see the `lossless` note on runOrDiagnose.
+    return runOrDiagnose(args, { account, lossless: true });
   });
 
   server.registerTool('gog_gmail_attachment', {

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

@@ -27,20 +27,20 @@ beforeEach(async () => {
 describe('gog_gmail_raw', () => {
   it('calls runOrDiagnose with messageId', async () => {
     await harness.callTool('gog_gmail_raw', { messageId: 'm1' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined, lossless: true });
   });
 
   it('passes --format and --pretty when provided', async () => {
     await harness.callTool('gog_gmail_raw', { messageId: 'm1', format: 'metadata', pretty: true });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['gmail', 'raw', 'm1', '--format=metadata', '--pretty'],
-      { account: undefined },
+      { account: undefined, lossless: true },
     );
   });
 
   it('omits --pretty when false', async () => {
     await harness.callTool('gog_gmail_raw', { messageId: 'm1', pretty: false });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined, lossless: true });
   });
 });