gogcli-mcp 2.25.0 → 2.26.0

package/src/tools/chat.ts

@@ -0,0 +1,253 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+  accountParam,
+  runOrDiagnose,
+  registerRunTool,
+  paginationParams,
+  pushPaginationFlags,
+} from './utils.js';
+import type { GogArg } from '../runner.js';
+import { attachInlineParam, inlineAttachmentArgs } from '../attachments.js';
+
+// Google Chat (gog >= 0.38.0 for the mention/reaction metadata in
+// `messages list`; the rest of the surface is older).
+//
+// TWO NAMING SYSTEMS MEET HERE, and mixing them is the mistake this module's
+// descriptions exist to prevent. Chat identifies everything by RESOURCE NAME —
+// `spaces/AAAA`, `spaces/AAAA/messages/BBBB`, `spaces/AAAA/threads/CCCC` — and
+// those names are what every tool below wants. A bare ID (`BBBB`) is accepted
+// for a message only when `space` says which space it lives in, which is why
+// the reaction tools carry that extra parameter.
+//
+// gog_chat_spaces_find / gog_chat_dm_space are the bridges from human words
+// ("the launch room", "alice@example.com") to those names; reach for one of
+// them first rather than guessing a resource name.
+//
+// WORKSPACE-ONLY, AND THAT IS NOT A SCOPE PROBLEM: gog refuses every chat call
+// on a consumer @gmail.com account with "chat requires a Google Workspace
+// account (non-gmail.com)" — verified live against gog 0.38.0 — no matter which
+// scopes the token carries. Re-authorizing cannot fix it, so the note below is
+// appended to every description here: a model that reads "permission error" as
+// "missing scope" would otherwise burn a re-auth round trip on an account that
+// can never work.
+export function registerChatTools(server: McpServer): void {
+  const workspaceOnlyNote =
+    ' WORKSPACE ONLY: Google Chat has no API for consumer accounts, so this fails on an @gmail.com '
+    + 'account with "chat requires a Google Workspace account". That is the ACCOUNT, not the token — '
+    + 're-authorizing or adding scopes will not help.';
+  const spaceParam = z.string().describe(
+    'Space resource name, e.g. "spaces/AAAAsomeID" (from gog_chat_spaces_list, gog_chat_spaces_find or gog_chat_dm_space)',
+  );
+  const threadParam = z.string().optional().describe(
+    'Thread resource name, e.g. "spaces/AAAA/threads/CCCC" — reply inside that thread instead of starting a new one',
+  );
+
+  server.registerTool('gog_chat_spaces_list', {
+    description:
+      'List the Google Chat spaces the account belongs to — named rooms and DMs alike — with their resource names. '
+      + 'Start here when you do not yet have a space name; gog_chat_spaces_find is faster when you know the room\'s title.'
+      + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ max, pageToken, page, all, account }) => {
+    const args = ['chat', 'spaces', 'list'];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_spaces_find', {
+    description:
+      'Find spaces whose display name matches. Substring and case-insensitive by default, which is what you want when the '
+      + 'user names a room approximately ("the launch room"); pass exact=true to require the whole title. DMs have no '
+      + 'display name — use gog_chat_dm_space to reach a person.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      displayName: z.string().describe('Space display name, or part of one'),
+      exact: z.boolean().optional().describe('Require an exact (still case-insensitive) match on the whole display name'),
+      max: z.number().int().optional().describe('Max results per page'),
+      account: accountParam,
+    },
+  }, async ({ displayName, exact, max, account }) => {
+    const args = ['chat', 'spaces', 'find', displayName];
+    if (exact) args.push('--exact');
+    if (max !== undefined) args.push(`--max=${max}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_spaces_create', {
+    description:
+      'Create a named Chat space, optionally seeding its membership. Members are added immediately and are notified — this '
+      + 'is visible to other people the moment it runs, so confirm the member list before calling it.' + workspaceOnlyNote,
+    inputSchema: {
+      displayName: z.string().describe('Display name for the new space'),
+      members: z.array(z.string()).optional().describe('Initial members, as email addresses or "users/..." resource names'),
+      account: accountParam,
+    },
+  }, async ({ displayName, members, account }) => {
+    const args = ['chat', 'spaces', 'create', displayName];
+    if (members) for (const member of members) args.push(`--member=${member}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_threads_list', {
+    description:
+      'List the threads in a space, so a reply can be targeted at an existing conversation rather than starting a new one. '
+      + 'Pass a thread name from here as `thread` to gog_chat_messages_send.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      space: spaceParam,
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ space, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'threads', 'list', space];
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_messages_list', {
+    description:
+      'Read messages in a space. The JSON carries each message\'s @-mentions and a summary of its emoji reactions '
+      + '(gog >= 0.38.0) alongside the text, so "who was tagged" and "did anyone react" are answerable without extra calls. '
+      + 'unread=true returns only what arrived after the account last read the space — the cheap way to answer "what did I '
+      + 'miss". Newest-first needs an explicit order="createTime desc"; Chat\'s own default is oldest-first.'
+      + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      space: spaceParam,
+      thread: threadParam,
+      unread: z.boolean().optional().describe('Only messages posted after the account last read this space'),
+      order: z.enum(['createTime asc', 'createTime desc', 'lastUpdateTime asc', 'lastUpdateTime desc'])
+        .optional().describe('Sort order (Chat default: "createTime asc", i.e. OLDEST first — ask for "createTime desc" when you want the latest messages)'),
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ space, thread, unread, order, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'messages', 'list', space];
+    if (thread) args.push(`--thread=${thread}`);
+    if (unread) args.push('--unread');
+    if (order) args.push(`--order=${order}`);
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_messages_send', {
+    description:
+      'Post a message to a Chat space. THIS IS IMMEDIATELY VISIBLE TO EVERYONE IN THE SPACE and cannot be unsent through '
+      + 'this tool, so treat it like sending mail, not like saving a draft. Pass `thread` to reply inside an existing '
+      + 'conversation (from gog_chat_threads_list or a message\'s thread field); omit it to start a new one. Text supports '
+      + 'Chat\'s markdown-ish formatting (*bold*, _italic_, `code`).' + workspaceOnlyNote,
+    inputSchema: {
+      space: spaceParam,
+      text: z.string().optional().describe('Message text. Optional only when an attachment is supplied.'),
+      thread: threadParam,
+      attach: z.array(z.string()).optional().describe(
+        'Attachment file paths, read WHERE GOG RUNS. On a hosted or remote deployment that is not your machine — use '
+        + 'attachInline there instead.',
+      ),
+      attachInline: attachInlineParam,
+      account: accountParam,
+    },
+  }, async ({ space, text, thread, attach, attachInline, account }) => {
+    if (text === undefined && !attach?.length && !attachInline?.length) {
+      throw new Error('A Chat message needs text, an attachment, or both.');
+    }
+    const args: GogArg[] = ['chat', 'messages', 'send', space];
+    if (text !== undefined) args.push(`--text=${text}`);
+    if (thread) args.push(`--thread=${thread}`);
+    if (attach) for (const path of attach) args.push(`--attach=${path}`);
+    // Same repeatable --attach flag; the executor materializes each payload to
+    // a temp file beside gog. `args` is passed so the size check sees the whole
+    // request, not just the attachments.
+    args.push(...inlineAttachmentArgs('attach', attachInline, args));
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_dm_send', {
+    description:
+      'Send a direct message to one person by email address, creating the DM space if this is the first message. Delivered '
+      + 'immediately and cannot be unsent through this tool. For a room rather than a person, use gog_chat_messages_send.'
+      + workspaceOnlyNote,
+    inputSchema: {
+      email: z.string().describe('Recipient email address'),
+      text: z.string().describe('Message text'),
+      thread: threadParam,
+      account: accountParam,
+    },
+  }, async ({ email, text, thread, account }) => {
+    const args = ['chat', 'dm', 'send', email, `--text=${text}`];
+    if (thread) args.push(`--thread=${thread}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_dm_space', {
+    description:
+      'Resolve the DM space for an email address — the bridge from a person to the "spaces/..." name the message tools '
+      + 'want. Creates the space if none exists yet, which is silent: it does not message the person.' + workspaceOnlyNote,
+    inputSchema: {
+      email: z.string().describe('The other person\'s email address'),
+      account: accountParam,
+    },
+  }, async ({ email, account }) => {
+    return runOrDiagnose(['chat', 'dm', 'space', email], { account });
+  });
+
+  server.registerTool('gog_chat_reactions_list', {
+    description:
+      'List the emoji reactions on one message, with who reacted. gog_chat_messages_list already returns a reaction '
+      + 'SUMMARY per message; come here when you need the individual reactors, or the reaction resource names that '
+      + 'gog_chat_reactions_delete takes.' + workspaceOnlyNote,
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
+      space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
+      ...paginationParams,
+      account: accountParam,
+    },
+  }, async ({ message, space, max, pageToken, page, all, account }) => {
+    const args = ['chat', 'messages', 'reactions', 'list', message];
+    if (space) args.push(`--space=${space}`);
+    pushPaginationFlags(args, { max, pageToken, page, all });
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_reactions_create', {
+    description:
+      'React to a message with an emoji. Visible to the space immediately. Pass the emoji itself ("👍"), not a :shortcode:.'
+      + workspaceOnlyNote,
+    inputSchema: {
+      message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
+      emoji: z.string().describe('The emoji character to react with, e.g. "👍"'),
+      space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
+      account: accountParam,
+    },
+  }, async ({ message, emoji, space, account }) => {
+    const args = ['chat', 'messages', 'reactions', 'create', message, emoji];
+    if (space) args.push(`--space=${space}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_chat_reactions_delete', {
+    description:
+      'Remove one emoji reaction. Takes the REACTION\'s own resource name ("spaces/.../messages/.../reactions/..."), not '
+      + 'the message\'s and not the emoji — get it from gog_chat_reactions_list. An account can only remove its own reaction.'
+      + workspaceOnlyNote,
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      reaction: z.string().describe('Reaction resource name, e.g. "spaces/AAAA/messages/BBBB/reactions/CCCC"'),
+      account: accountParam,
+    },
+  }, async ({ reaction, account }) => {
+    return runOrDiagnose(['chat', 'messages', 'reactions', 'delete', reaction], { account });
+  });
+
+  registerRunTool(server, {
+    service: 'chat',
+    examples: '"spaces", "messages", "dm"',
+    note: 'Google Chat has no API for consumer accounts: every chat subcommand fails on an @gmail.com account regardless of scopes.',
+  });
+}

package/src/worker.ts

@@ -38,7 +38,7 @@ import { gogAuth, CONNECTOR_INSTRUCTIONS, type GogProps } from './connector-auth
 // connector with all ~360 tools at once. Add whichever paths you want as separate
 // connectors in claude.ai (each authorizes with the same connector key).
 
-const VERSION = '2.25.0'; // x-release-please-version
+const VERSION = '2.26.0'; // x-release-please-version
 
 // Build an McpAgent subclass whose init() registers `registrars` onto its server,
 // each handler wrapped in the ALS scope carrying the per-session Fly executor.

package/tests/gmail-results.test.ts

@@ -255,6 +255,53 @@ describe('fetchGmailPages', () => {
     expect(runPage).toHaveBeenCalledTimes(2);
   });
 
+  // A REPEATED CURSOR IS A STALL, and gog 0.38.0 fixed the same class on its own
+  // side (openclaw/gogcli#1004) — but that fix covers gog's `--all`, and this
+  // walk is our own: it makes N separate single-page gog calls, so a cursor
+  // Google repeats comes straight back to this loop. Without a guard the walk
+  // re-fetches the same page and merges its items again on every remaining
+  // iteration, so the caller gets DUPLICATES presented as more results, which is
+  // worse than a short answer because nothing about the payload looks wrong.
+  it('stops when Google repeats a cursor, instead of re-fetching the same page', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a', 'b']);
+    // Stopped after the repeat was seen — NOT after burning all 10 pages.
+    expect(runPage).toHaveBeenCalledTimes(2);
+  });
+
+  it('still reads as truncated after a repeated cursor', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    // The walk could not reach the end, so the cursor STAYS. Dropping it would
+    // claim completeness we never established, and a set that reads complete is
+    // exactly how "that email doesn't exist" gets reported about mail that does.
+    expect(out.nextPageToken).toBe('T1');
+  });
+
+  it('detects a cursor that repeats the caller-supplied one', async () => {
+    const runPage = vi.fn().mockResolvedValueOnce(page(['a'], 'START'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, 'START')).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a']);
+    expect(out.nextPageToken).toBe('START');
+    expect(runPage).toHaveBeenCalledTimes(1);
+  });
+
+  it('detects a cursor that repeats a token from earlier in the walk, not just the previous one', async () => {
+    const runPage = vi.fn()
+      .mockResolvedValueOnce(page(['a'], 'T1'))
+      .mockResolvedValueOnce(page(['b'], 'T2'))
+      .mockResolvedValueOnce(page(['c'], 'T1'));
+    const out = JSON.parse((await fetchGmailPages(runPage, 'threads', 10, undefined)).content[0].text as string);
+    expect(out.threads.map((t: { id: string }) => t.id)).toEqual(['a', 'b', 'c']);
+    expect(out.nextPageToken).toBe('T1');
+    expect(runPage).toHaveBeenCalledTimes(3);
+  });
+
   it('starts from a caller-supplied cursor', async () => {
     const runPage = vi.fn().mockResolvedValue(page(['a']));
     await fetchGmailPages(runPage, 'threads', 3, 'START');

package/tests/server.test.ts

@@ -14,8 +14,10 @@ describe('BASE_TOOL_REGISTRARS', () => {
     // One representative tool per service registrar, in registrar order.
     for (const expected of [
       'gog_api_list',
+      'gog_appscript_get',
       'gog_auth_list',
       'gog_calendar_events',
+      'gog_chat_spaces_list',
       'gog_classroom_courses_list',
       'gog_contacts_list',
       'gog_docs_cat',

package/tests/tools/appscript.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerAppScriptTools } from '../../src/tools/appscript.js';
+import * as runner from '../../src/runner.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+
+vi.mock('../../src/runner.js');
+
+const setupHandlers = () => createTestHarness(registerAppScriptTools);
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('gog_appscript_get', () => {
+  it('gets project metadata', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_get', { scriptId: 'S1' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'get', 'S1'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Get failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_get', { scriptId: 'S1' });
+    expect(result.content[0].text).toBe('Error: Get failed');
+  });
+});
+
+describe('gog_appscript_content', () => {
+  it('reads the project source', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_content', { scriptId: 'S1', account: 'me@x.com' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'content', 'S1'], { account: 'me@x.com' });
+  });
+});
+
+describe('gog_appscript_pull', () => {
+  it('pulls into a directory', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_pull', { scriptId: 'S1', dir: '/tmp/proj' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'pull', 'S1', '/tmp/proj'], { account: undefined });
+  });
+
+  it('passes --overwrite', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_pull', { scriptId: 'S1', dir: '/tmp/proj', overwrite: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'pull', 'S1', '/tmp/proj', '--overwrite'],
+      { account: undefined },
+    );
+  });
+
+  // The directory resolves where gog runs, which is a different machine on the
+  // hosted connector. A caller who does not know that gets a "success" whose
+  // files they cannot reach.
+  it('says in its description where the directory resolves', async () => {
+    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+    const server = new McpServer({ name: 'test', version: '0.0.0' });
+    const configs = new Map<string, { description?: string }>();
+    vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {
+      configs.set(name, config as { description?: string });
+      return undefined as never;
+    });
+    registerAppScriptTools(server);
+    const desc = configs.get('gog_appscript_pull')?.description ?? '';
+    expect(desc).toContain('RESOLVED WHERE GOG RUNS');
+    expect(desc).toMatch(/gog_appscript_content/);
+  });
+});
+
+describe('gog_appscript_create', () => {
+  it('creates a standalone project', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_create', { title: 'Helpers' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'create', '--title=Helpers'], { account: undefined });
+  });
+
+  it('binds the project to a Drive file', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_create', { title: 'Bound', parentId: 'FILE1' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'create', '--title=Bound', '--parent-id=FILE1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_appscript_deployments', () => {
+  it('lists deployments with pagination', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_deployments', { scriptId: 'S1', max: 10, pageToken: 'tok' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'deployments', 'S1', '--max=10', '--page=tok'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_appscript_versions', () => {
+  it('lists versions', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_versions', { scriptId: 'S1', all: true });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'versions', 'S1', '--all'], { account: undefined });
+  });
+});
+
+describe('gog_appscript_run_function', () => {
+  it('runs a deployed function', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run_function', { scriptId: 'S1', functionName: 'doWork' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'run', 'S1', 'doWork'], { account: undefined });
+  });
+
+  it('passes params and --dev-mode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: '["a",1]', devMode: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'run', 'S1', 'doWork', '--params=["a",1]', '--dev-mode'],
+      { account: undefined },
+    );
+  });
+
+  it('rejects params that are not a JSON array before spawning gog', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: '{"a":1}',
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('rejects params that are not JSON at all', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: 'a,1',
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_appscript_run', () => {
+  it('passes the subcommand and args through', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run', { subcommand: 'get', args: ['S1'] });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'get', 'S1'], { account: undefined });
+  });
+});

package/tests/tools/calendar.test.ts

@@ -457,3 +457,124 @@ describe('gog_calendar_events — pagination (previously absent entirely)', () =
     expect(out).not.toHaveProperty('nextPageToken');
   });
 });
+
+// Reminders (gog >= 0.38.0 for --no-reminders, openclaw/gogcli#1002/#1016).
+// Three distinct states share these two params and gog spells each one
+// differently, so each is pinned separately: custom overrides, "no reminders at
+// all", and — on update only — "go back to whatever the calendar says", which
+// is an EMPTY --reminder rather than a flag of its own. All three were verified
+// against a real gog 0.38.0 with --dry-run.
+describe('gog_calendar_create reminders', () => {
+  it('passes each reminder as its own repeated flag', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Standup',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:30m', 'email:1d'],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'create', 'primary', '--summary=Standup', '--from=2026-04-14T09:00:00Z', '--to=2026-04-14T09:30:00Z',
+        '--reminder=popup:30m', '--reminder=email:1d'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --no-reminders', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Quiet',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      noReminders: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'create', 'primary', '--summary=Quiet', '--from=2026-04-14T09:00:00Z', '--to=2026-04-14T09:30:00Z',
+        '--no-reminders'],
+      { account: undefined },
+    );
+  });
+
+  it('rejects reminders and noReminders together, as gog does', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Both',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:10m'],
+      noReminders: true,
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('rejects more than the five reminders Google allows', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Too many',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:1m', 'popup:2m', 'popup:3m', 'popup:4m', 'popup:5m', 'popup:6m'],
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_calendar_update reminders', () => {
+  it('replaces the overrides', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', reminders: ['popup:15m'],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--reminder=popup:15m'],
+      { account: undefined },
+    );
+  });
+
+  // Verified live: `calendar update … --reminder= --dry-run` patches
+  // reminders.useDefault=true with overrides cleared.
+  it('restores the calendar defaults with an empty reminder list', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', reminders: [],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--reminder='],
+      { account: undefined },
+    );
+  });
+
+  it('turns every reminder off', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', noReminders: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--no-reminders'],
+      { account: undefined },
+    );
+  });
+
+  it('leaves reminders alone when neither param is given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', summary: 'Renamed',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--summary=Renamed'],
+      { account: undefined },
+    );
+  });
+});