gogcli-mcp-docs 2.18.3 → 2.19.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Extended Google Docs for Claude via gogcli — auth + full Docs and comments support",
-    "version": "2.18.3"
+    "version": "2.19.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli (Docs)",
       "source": "./",
       "description": "Extended Google Docs for Claude via gogcli — auth + full Docs and comments support",
-      "version": "2.18.3",
+      "version": "2.19.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp-docs",
   "displayName": "gogcli (Docs)",
-  "version": "2.18.3",
+  "version": "2.19.0",
   "description": "Extended Google Docs for Claude via gogcli — auth + full Docs and comments support",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -3644,7 +3644,12 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -3770,6 +3775,7 @@ var require_fast_uri = __commonJS({
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -3804,6 +3810,20 @@ var require_fast_uri = __commonJS({
         parsed.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -31275,6 +31295,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 +31592,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);
   }
@@ -31660,7 +31873,68 @@ 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.19.0" : "0.0.0";
+
+// ../gogcli-mcp/src/connector-runtime.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEADLINE_GRACE_MS = 5e3;
+var RUNNER_GOG_FAILED = 422;
+var RUNNER_DRAINING = 503;
+function makeFlyExecutor(endpoint, key) {
+  return async (args, opts) => {
+    const deadlineMs = (opts?.timeout ?? DEFAULT_TIMEOUT_MS) + DEADLINE_GRACE_MS;
+    let res;
+    try {
+      res = await fetch(endpoint + "/run", {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer " + key,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ args }),
+        signal: AbortSignal.timeout(deadlineMs)
+      });
+    } catch (err) {
+      const name = err instanceof Error ? err.name : "";
+      if (name === "TimeoutError" || name === "AbortError") {
+        throw new Error(
+          `gog-runner did not respond within ${deadlineMs}ms (${endpoint}) \u2014 the Fly backend may be cold or wedged`
+        );
+      }
+      throw err;
+    }
+    if (!res.ok) {
+      const body = await res.json().catch(() => null);
+      const detail = body && typeof body.error === "string" ? body.stderr && body.stderr.trim() && body.stderr.trim() !== body.error.trim() ? `${body.error}
+${body.stderr}` : body.error : "";
+      if (res.status === RUNNER_GOG_FAILED) {
+        throw new Error(detail || "gog failed on the runner (no detail supplied)");
+      }
+      if (res.status === RUNNER_DRAINING || body?.retryable === true) {
+        throw new Error(
+          `gog-runner is restarting; retry this call.${detail ? ` ${detail}` : ""}`
+        );
+      }
+      if (detail) {
+        throw new Error(detail);
+      }
+      throw new Error(
+        `gog-runner HTTP ${res.status}: the response did not come from the runner, so the request never reached gog. The backend Machine was most likely starting or shutting down \u2014 this is transient, retry the same call.`
+      );
+    }
+    const { stdout } = await res.json();
+    return stdout;
+  };
+}
+
+// ../gogcli-mcp/src/remote-runner.ts
+function useRemoteGogRunner(env = process.env) {
+  const endpoint = readEnvVar("GOG_RUNNER_URL", { env });
+  const key = readEnvVar("GOG_RUNNER_KEY", { env });
+  if (!endpoint || !key) return false;
+  runExecutor.enterWith({ executor: makeFlyExecutor(endpoint.replace(/\/+$/, ""), key) });
+  return true;
+}
 
 // src/tools/docs-extra.ts
 function registerExtraDocsTools(server) {
@@ -31747,7 +32021,7 @@ function registerExtraDocsTools(server) {
       const args2 = ["docs", "raw", docId, "--pretty"];
       if (tab) args2.push(`--tab=${tab}`);
       if (allTabs) args2.push("--all-tabs");
-      return runOrDiagnose(args2, { account });
+      return runOrDiagnose(args2, { account, lossless: true });
     }
     const args = ["docs", "cat", docId];
     if (tab) args.push(`--tab=${tab}`);
@@ -33009,6 +33283,7 @@ function registerExtraDocsTools(server) {
 }
 
 // src/index.ts
+useRemoteGogRunner();
 await runMcp({
   name: "gogcli-docs",
   version: VERSION,

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-docs",
   "display_name": "gogcli (Docs)",
-  "version": "2.18.3",
+  "version": "2.19.0",
   "description": "Extended Google Docs for Claude via gogcli — auth + full Docs and comments support",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-docs",
-  "version": "2.18.3",
+  "version": "2.19.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-docs",
   "description": "Extended Google Docs MCP server via gogcli — all base tools plus full Docs support",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp-docs"
   },
-  "version": "2.18.3",
+  "version": "2.19.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp-docs",
-      "version": "2.18.3",
+      "version": "2.19.0",
       "transport": {
         "type": "stdio"
       },

package/src/index.ts

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import { runMcp } from '@chrischall/mcp-utils';
-import { VERSION, authToolsFor, registerDocsTools } from '../../gogcli-mcp/src/lib.js';
+import { VERSION, authToolsFor, registerDocsTools, useRemoteGogRunner } from '../../gogcli-mcp/src/lib.js';
 import { registerExtraDocsTools } from './tools/docs-extra.js';
 
+
+// Execute `gog` on the Fly backend when the host points us at one; without
+// it, nothing changes and we spawn the local binary as before.
+useRemoteGogRunner();
+
 await runMcp({
   name: 'gogcli-docs',
   version: VERSION,

package/src/tools/docs-extra.ts

@@ -91,7 +91,8 @@ export function registerExtraDocsTools(server: McpServer): void {
       const args = ['docs', 'raw', docId, '--pretty'];
       if (tab) args.push(`--tab=${tab}`);
       if (allTabs) args.push('--all-tabs');
-      return runOrDiagnose(args, { account });
+      // Verbatim by contract: see the `lossless` note on runOrDiagnose.
+      return runOrDiagnose(args, { account, lossless: true });
     }
     const args = ['docs', 'cat', docId];
     if (tab) args.push(`--tab=${tab}`);

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

@@ -748,7 +748,7 @@ describe('gog_docs_read', () => {
     vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
     const harness = await setupHandlers();
     await harness.callTool('gog_docs_read', { docId: 'd1', format: 'json' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty'], { account: undefined, lossless: true });
   });
 
   it('passes tab, allTabs, maxBytes in text mode', async () => {
@@ -772,7 +772,7 @@ describe('gog_docs_read', () => {
     vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
     const harness = await setupHandlers();
     await harness.callTool('gog_docs_read', { docId: 'd1', format: 'json', chips: true });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty'], { account: undefined, lossless: true });
   });
 });
 
@@ -1576,14 +1576,14 @@ describe('gog_docs_read json tab targeting', () => {
     vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
     const harness = await setupHandlers();
     await harness.callTool('gog_docs_read', { docId: 'd1', format: 'json', tab: 'T' });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty', '--tab=T'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty', '--tab=T'], { account: undefined, lossless: true });
   });
 
   it('passes --all-tabs through to docs raw in json mode', async () => {
     vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
     const harness = await setupHandlers();
     await harness.callTool('gog_docs_read', { docId: 'd1', format: 'json', allTabs: true });
-    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty', '--all-tabs'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['docs', 'raw', 'd1', '--pretty', '--all-tabs'], { account: undefined, lossless: true });
   });
 });