gogcli-mcp 2.25.0 → 2.26.0

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp",
   "display_name": "gogcli",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",
@@ -423,6 +423,86 @@
     {
       "name": "gog_slides_run",
       "description": "Run any gog slides subcommand (escape hatch)"
+    },
+    {
+      "name": "gog_chat_spaces_list",
+      "description": "List the Google Chat spaces the account belongs to, with their resource names"
+    },
+    {
+      "name": "gog_chat_spaces_find",
+      "description": "Find Chat spaces by display name (substring by default, or exact)"
+    },
+    {
+      "name": "gog_chat_spaces_create",
+      "description": "Create a named Chat space, optionally seeding its membership"
+    },
+    {
+      "name": "gog_chat_threads_list",
+      "description": "List the threads in a Chat space"
+    },
+    {
+      "name": "gog_chat_messages_list",
+      "description": "Read messages in a space, with mentions and reaction summaries"
+    },
+    {
+      "name": "gog_chat_messages_send",
+      "description": "Post a message to a Chat space (immediately visible; supports attachments)"
+    },
+    {
+      "name": "gog_chat_dm_send",
+      "description": "Send a direct message to one person by email address"
+    },
+    {
+      "name": "gog_chat_dm_space",
+      "description": "Resolve the DM space resource name for an email address"
+    },
+    {
+      "name": "gog_chat_reactions_list",
+      "description": "List the emoji reactions on a message, with who reacted"
+    },
+    {
+      "name": "gog_chat_reactions_create",
+      "description": "React to a Chat message with an emoji"
+    },
+    {
+      "name": "gog_chat_reactions_delete",
+      "description": "Remove one emoji reaction by its resource name"
+    },
+    {
+      "name": "gog_chat_run",
+      "description": "Run any gog chat subcommand not covered by the other tools"
+    },
+    {
+      "name": "gog_appscript_get",
+      "description": "Get an Apps Script project's metadata"
+    },
+    {
+      "name": "gog_appscript_content",
+      "description": "Read a project's source files and manifest inline"
+    },
+    {
+      "name": "gog_appscript_pull",
+      "description": "Write a project's files into a directory on the machine where gog runs"
+    },
+    {
+      "name": "gog_appscript_create",
+      "description": "Create a new, empty Apps Script project (optionally bound to a Drive file)"
+    },
+    {
+      "name": "gog_appscript_deployments",
+      "description": "List a project's deployments"
+    },
+    {
+      "name": "gog_appscript_versions",
+      "description": "List a project's saved versions"
+    },
+    {
+      "name": "gog_appscript_run_function",
+      "description": "Execute a function in a deployed Apps Script project"
+    },
+    {
+      "name": "gog_appscript_run",
+      "description": "Run any gog appscript subcommand not covered by the other tools"
     }
   ],
   "compatibility": {

package/mint.yaml

@@ -0,0 +1,106 @@
+version: 1
+name: gogcli (Google Workspace)
+slug: gogcli-mcp
+summary: >-
+  MCP server wrapping gogcli for Google service access
+command:
+  # This package publishes a single bin; naming it keeps the install
+  # unambiguous alongside its eight sibling packages.
+  bin: gogcli-mcp
+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",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "mcpName": "io.github.chrischall/gogcli-mcp",
   "description": "MCP server wrapping gogcli for Google service access",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -41,15 +41,15 @@
     "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"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@vitest/coverage-v8": "^4.1.8",
-    "esbuild": "^0.28.1",
+    "esbuild": "^0.28.2",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   }
 }

package/server.json

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

package/src/gmail-results.ts

@@ -177,6 +177,16 @@ export async function finalizeGmailSearch(
 // The merged payload keeps a nextPageToken only if pages remain when the cap is
 // hit, so finalizeGmailSearch still marks it truncated — running out of budget
 // is not the same as reaching the end, and must not read like it.
+//
+// A REPEATED CURSOR ENDS THE WALK TOO. Google can hand back a nextPageToken it
+// has already issued, and gog 0.38.0 fixed exactly that for its own `--all`
+// (openclaw/gogcli#1004) — but this walk is not gog's: it makes N separate
+// single-page calls, so a repeated cursor arrives here untouched. Following it
+// re-fetches a page already merged, so the caller gets the same threads twice
+// over, presented as more results and looking perfectly well-formed. The token
+// is KEPT when that happens, for the same reason the cap keeps it: the walk
+// never established an end, and a set that reads complete is precisely how mail
+// that exists gets reported as missing.
 export async function fetchGmailPages(
   runPage: (token: string | undefined) => Promise<CallToolResult>,
   itemsKey: 'threads' | 'messages',
@@ -186,6 +196,10 @@ export async function fetchGmailPages(
   const merged: unknown[] = [];
   let base: Record<string, unknown> | undefined;
   let token = startToken;
+  // Every cursor this walk has already fetched with, so one Google repeats is
+  // recognised rather than followed. Seeded with the caller's own cursor: a
+  // response echoing that back would re-fetch the page just merged.
+  const fetched = new Set<string>(startToken === undefined ? [] : [startToken]);
 
   for (let pages = 0; pages < maxPages; pages++) {
     const result = await runPage(token);
@@ -199,10 +213,23 @@ export async function fetchGmailPages(
     }
     base = parsed;
     merged.push(...(parsed[itemsKey] as unknown[]));
-    token = typeof parsed.nextPageToken === 'string' && parsed.nextPageToken !== ''
+    const next = typeof parsed.nextPageToken === 'string' && parsed.nextPageToken !== ''
       ? parsed.nextPageToken
       : undefined;
-    if (token === undefined) break;
+    if (next === undefined) {
+      token = undefined;
+      break;
+    }
+    // Checked BEFORE the next fetch, so the duplicate page is never requested
+    // and never merged. `token` keeps the repeated cursor so the result still
+    // reads as truncated — it is the honest answer, and handing it back lets a
+    // caller retry later rather than concluding there is nothing more.
+    if (fetched.has(next)) {
+      token = next;
+      break;
+    }
+    fetched.add(next);
+    token = next;
   }
 
   return finish(base as Record<string, unknown>, itemsKey, merged, token);

package/src/lib.ts

@@ -2,9 +2,11 @@ export {
   BASE_TOOL_REGISTRARS,
   VERSION,
   registerApiTools,
+  registerAppScriptTools,
   registerAuthTools,
   authToolsFor,
   registerCalendarTools,
+  registerChatTools,
   registerClassroomTools,
   registerContactsTools,
   registerDocsTools,

package/src/runner.ts

@@ -217,7 +217,7 @@ const TIMEOUT_MS = 30_000;
 // so the requirement change is surfaced in the release notes (see
 // .github/release.yml). This is the single source of truth for the required
 // version; keep the README/CLAUDE.md mention in sync.
-export const MIN_GOG_VERSION = '0.37.0';
+export const MIN_GOG_VERSION = '0.38.1';
 
 // Interpret the GOG_READONLY kill-switch. `readEnvVar` already treats blank
 // values, 'undefined'/'null' sentinels, and unresolved .mcpb placeholders

package/src/server.ts

@@ -1,7 +1,9 @@
 import type { ToolRegistrar } from '@chrischall/mcp-utils';
 import { registerApiTools } from './tools/api.js';
+import { registerAppScriptTools } from './tools/appscript.js';
 import { registerAuthTools, authToolsFor } from './tools/auth.js';
 import { registerCalendarTools } from './tools/calendar.js';
+import { registerChatTools } from './tools/chat.js';
 import { registerClassroomTools } from './tools/classroom.js';
 import { registerContactsTools } from './tools/contacts.js';
 import { registerDocsTools } from './tools/docs.js';
@@ -23,8 +25,10 @@ export const VERSION = typeof GOGCLI_VERSION !== 'undefined' ? GOGCLI_VERSION :
 // re-exported below.
 export const BASE_TOOL_REGISTRARS: ToolRegistrar[] = [
   registerApiTools,
+  registerAppScriptTools,
   registerAuthTools,
   registerCalendarTools,
+  registerChatTools,
   registerClassroomTools,
   registerContactsTools,
   registerDocsTools,
@@ -37,9 +41,11 @@ export const BASE_TOOL_REGISTRARS: ToolRegistrar[] = [
 
 export {
   registerApiTools,
+  registerAppScriptTools,
   registerAuthTools,
   authToolsFor,
   registerCalendarTools,
+  registerChatTools,
   registerClassroomTools,
   registerContactsTools,
   registerDocsTools,

package/src/tools/appscript.ts

@@ -0,0 +1,173 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+  accountParam,
+  runOrDiagnose,
+  registerRunTool,
+  paginationParams,
+  pushPaginationFlags,
+} from './utils.js';
+
+// Google Apps Script (gog >= 0.38.0 for pull/deployments/versions).
+//
+// This wraps the READ and RUN halves of the Apps Script API. gog has no push,
+// so nothing here can change a project's code: `create` makes an empty project
+// and `pull`/`content` only copy code outwards. The one tool with real reach is
+// gog_appscript_run_function, which executes somebody's script under this
+// account's authority — see its description.
+//
+// The Apps Script API is OFF by default on a Google Cloud project, so the first
+// call on a fresh OAuth client fails with "Apps Script API is not enabled for
+// this OAuth project" and a console URL. That error is gog's, it names the
+// exact project, and it is not a scope failure — do not answer it with a
+// re-auth.
+export function registerAppScriptTools(server: McpServer): void {
+  const scriptIdParam = z.string().describe(
+    'Apps Script project ID — the long ID in script.google.com/…/projects/<scriptId>/…, NOT the Drive file ID of a '
+    + 'container document',
+  );
+  const apiEnableNote =
+    ' Needs the Apps Script API enabled on the OAuth client\'s Google Cloud project; if it is not, gog says so and prints '
+    + 'the console URL to enable it. That is a project setting, not a missing scope — re-authorizing will not fix it.';
+
+  server.registerTool('gog_appscript_get', {
+    description:
+      'Get an Apps Script project\'s metadata: title, creator, create/update times, and the parent Drive file when the '
+      + 'project is bound to a Sheet, Doc or Form. Use gog_appscript_content to read the actual code.' + apiEnableNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      scriptId: scriptIdParam,
+      account: accountParam,
+    },
+  }, async ({ scriptId, account }) => {
+    return runOrDiagnose(['appscript', 'get', scriptId], { account });
+  });
+
+  server.registerTool('gog_appscript_content', {
+    description:
+      'Read a project\'s source — every .gs file and its appsscript.json manifest — INLINE in the response. This is the '
+      + 'tool to reach for when the question is "what does this script do"; it needs no filesystem, so it works the same '
+      + 'on a hosted deployment as it does locally, unlike gog_appscript_pull.' + apiEnableNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      scriptId: scriptIdParam,
+      account: accountParam,
+    },
+  }, async ({ scriptId, account }) => {
+    return runOrDiagnose(['appscript', 'content', scriptId], { account });
+  });
+
+  server.registerTool('gog_appscript_pull', {
+    description:
+      'Write a project\'s files into a local directory, for editing a script as ordinary files. '
+      + 'THE DIRECTORY IS RESOLVED WHERE GOG RUNS, which is the caller\'s own machine only on a local (stdio) deployment: '
+      + 'on the hosted connector, or any GOG_RUNNER_URL backend, the files land on that server where the caller cannot '
+      + 'reach them. Use gog_appscript_content there instead — it returns the same source in the response. Existing files '
+      + 'are left alone unless overwrite is set. Read-only as far as Google is concerned: nothing is pushed back.'
+      + apiEnableNote,
+    inputSchema: {
+      scriptId: scriptIdParam,
+      dir: z.string().describe('Destination directory, resolved on the machine where gog runs'),
+      overwrite: z.boolean().optional().describe('Overwrite files that already exist in dir'),
+      account: accountParam,
+    },
+  }, async ({ scriptId, dir, overwrite, account }) => {
+    const args = ['appscript', 'pull', scriptId, dir];
+    if (overwrite) args.push('--overwrite');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_appscript_create', {
+    description:
+      'Create a new, empty Apps Script project. Pass parentId to bind it to a Drive file (a Sheet, Doc or Form), which is '
+      + 'what makes the script a container-bound script with access to that document; omit it for a standalone project. '
+      + 'gog cannot upload code, so the project starts empty either way.' + apiEnableNote,
+    inputSchema: {
+      title: z.string().describe('Project title'),
+      parentId: z.string().optional().describe('Drive file ID to bind the project to (Sheet, Doc or Form). Omit for a standalone project.'),
+      account: accountParam,
+    },
+  }, async ({ title, parentId, account }) => {
+    const args = ['appscript', 'create', `--title=${title}`];
+    if (parentId) args.push(`--parent-id=${parentId}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_appscript_deployments', {
+    description:
+      'List a project\'s deployments — the published web apps, add-ons and API executables, each pinned to a version. A '
+      + 'deployment ID from here is what gog_appscript_run_function needs when a script is not running in dev mode.'
+      + apiEnableNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      scriptId: scriptIdParam,
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ scriptId, max, pageToken, page, all, account }) => {
+    const args = ['appscript', 'deployments', scriptId];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_appscript_versions', {
+    description:
+      'List a project\'s saved versions — the immutable snapshots deployments point at, with their numbers and '
+      + 'descriptions. Useful for answering "what is actually deployed" next to gog_appscript_deployments.' + apiEnableNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      scriptId: scriptIdParam,
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ scriptId, max, pageToken, page, all, account }) => {
+    const args = ['appscript', 'versions', scriptId];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_appscript_run_function', {
+    description:
+      'Execute a function in a deployed Apps Script project. TREAT THIS AS ARBITRARY CODE EXECUTION: the script runs with '
+      + 'this Google account\'s authority and can send mail, edit Drive files or call external services, and the wrapper '
+      + 'cannot tell a read from a write — read the code with gog_appscript_content first if you did not write it. '
+      + 'Requires the project to be deployed as an API executable and to share the OAuth client with the calling '
+      + 'credentials, otherwise Google refuses regardless of scopes. devMode runs the latest saved code instead of the '
+      + 'deployed version, and only works if the account owns the script. '
+      + 'This is NOT the escape hatch — gog_appscript_run is that.' + apiEnableNote,
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      scriptId: scriptIdParam,
+      functionName: z.string().describe('Name of the function to call, e.g. "doWork"'),
+      params: z.string().optional().describe('Function parameters as a JSON ARRAY of positional arguments, e.g. \'["a", 1]\' — not an object'),
+      devMode: z.boolean().optional().describe('Run the latest saved code rather than the deployed version (owner only)'),
+      account: accountParam,
+    },
+  }, async ({ scriptId, functionName, params, devMode, account }) => {
+    // gog passes --params through to the API as-is, so a malformed value comes
+    // back as a Google error about the request body rather than about the
+    // argument the caller actually got wrong. Checking the shape here is what
+    // turns "invalid argument" into "params must be a JSON array".
+    if (params !== undefined) {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(params);
+      } catch {
+        throw new Error(`params must be a JSON array of positional arguments, e.g. '["a", 1]'. Received: ${params}`);
+      }
+      if (!Array.isArray(parsed)) {
+        throw new Error(`params must be a JSON ARRAY of positional arguments, e.g. '["a", 1]' — Apps Script takes positional arguments, not named ones. Received: ${params}`);
+      }
+    }
+    const args = ['appscript', 'run', scriptId, functionName];
+    if (params !== undefined) args.push(`--params=${params}`);
+    if (devMode) args.push('--dev-mode');
+    return runOrDiagnose(args, { account });
+  });
+
+  registerRunTool(server, {
+    service: 'appscript',
+    examples: '"get", "content", "deployments"',
+    note: 'To execute a function, use gog_appscript_run_function — this tool is the generic escape hatch.',
+  });
+}

package/src/tools/calendar.ts

@@ -3,6 +3,56 @@ import { z } from 'zod';
 import { accountParam, runOrDiagnose, registerRunTool, pageTokenParam, pageAliasParam, resolvePageToken } from './utils.js';
 import { annotateTruncatedList } from '../pagination.js';
 
+// Reminder params, shared by create and update (gog >= 0.38.0 for
+// --no-reminders). An event's reminders are one of THREE states, and the two
+// params below have to spell all three because gog does:
+//
+//   reminders: ['popup:30m']  →  --reminder=popup:30m   custom overrides
+//   noReminders: true         →  --no-reminders         no reminder at all
+//   reminders: []             →  --reminder=            back to the calendar's defaults
+//
+// That last one is the subtle one and it only means anything on update: gog
+// reads an EMPTY --reminder as "clear the overrides and use the calendar
+// default" (openclaw/gogcli#1016), which is a different outcome from omitting
+// the flag (leave whatever the event already has) and from --no-reminders
+// (override the calendar with silence). An empty array is how a JSON caller
+// says it, since there is no way to send a bare flag with no value.
+const reminderParams = {
+  reminders: z.array(z.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 — on update, pass an '
+    + 'EMPTY array to drop custom reminders and go back to the calendar\'s defaults. Cannot be combined with noReminders.',
+  ),
+  noReminders: z.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.',
+  ),
+};
+
+// The one place the three states become argv. Kept together so create and
+// update cannot drift apart on the empty-array case.
+function pushReminderFlags(
+  args: string[],
+  p: { reminders?: string[]; noReminders?: boolean },
+): void {
+  if (p.noReminders) {
+    // gog's own flags are `xor:"reminders"`, so it would reject this too — but
+    // only after a spawn, and with kong's wording rather than the tool's.
+    if (p.reminders !== undefined) {
+      throw new Error('reminders and noReminders are mutually exclusive: pass reminders to set custom ones, noReminders for none, or an empty reminders array to restore the calendar defaults.');
+    }
+    args.push('--no-reminders');
+    return;
+  }
+  if (p.reminders === undefined) return;
+  // Empty array → one empty --reminder, which is gog's "restore defaults".
+  if (p.reminders.length === 0) {
+    args.push('--reminder=');
+    return;
+  }
+  for (const reminder of p.reminders) args.push(`--reminder=${reminder}`);
+}
+
 export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_events', {
     description: 'List calendar events. Describe the window ONE way and one way only (gog >= 0.36.0 rejects the rest as ambiguous rather than silently discarding a flag): '
@@ -80,9 +130,10 @@ export function registerCalendarTools(server: McpServer): void {
       allDay: z.boolean().optional().describe('All-day event (use date-only in from/to)'),
       timezone: z.string().optional().describe('IANA timezone metadata applied to from/to (e.g. America/New_York). Sets both start and end timezone unless start/end timezone are overridden.'),
       withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event (requires Zoom S2S OAuth setup)'),
+      ...reminderParams,
       account: accountParam,
     },
-  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, timezone, withZoom, account }) => {
+  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, timezone, withZoom, reminders, noReminders, account }) => {
     const args = ['calendar', 'create', calendarId, `--summary=${summary}`, `--from=${from}`, `--to=${to}`];
     if (description) args.push(`--description=${description}`);
     if (location) args.push(`--location=${location}`);
@@ -90,6 +141,7 @@ export function registerCalendarTools(server: McpServer): void {
     if (allDay) args.push('--all-day');
     if (timezone) args.push(`--timezone=${timezone}`);
     if (withZoom) args.push('--with-zoom');
+    pushReminderFlags(args, { reminders, noReminders });
     return runOrDiagnose(args, { account });
   });
 
@@ -111,9 +163,10 @@ export function registerCalendarTools(server: McpServer): void {
       regenerateZoom: z.boolean().optional().describe('Replace the event\'s existing Zoom video conference'),
       removeZoom: z.boolean().optional().describe('Remove the event\'s Zoom video conference'),
       removeMeet: z.boolean().optional().describe('Remove the event\'s Google Meet video conference (clears conference data only)'),
+      ...reminderParams,
       account: accountParam,
     },
-  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, addAttendees, attachments, withZoom, regenerateZoom, removeZoom, removeMeet, account }) => {
+  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, addAttendees, attachments, withZoom, regenerateZoom, removeZoom, removeMeet, reminders, noReminders, account }) => {
     const args = ['calendar', 'update', calendarId, eventId];
     if (summary !== undefined) args.push(`--summary=${summary}`);
     if (from !== undefined) args.push(`--from=${from}`);
@@ -127,6 +180,7 @@ export function registerCalendarTools(server: McpServer): void {
     if (regenerateZoom) args.push('--regenerate-zoom');
     if (removeZoom) args.push('--remove-zoom');
     if (removeMeet) args.push('--remove-meet');
+    pushReminderFlags(args, { reminders, noReminders });
     return runOrDiagnose(args, { account });
   });