gogcli-mcp 2.24.0 → 2.26.0

package/tests/runner-file-args-failure.test.ts

@@ -8,11 +8,13 @@ import type { Spawner } from '../src/runner.js';
 // its own file because the mock would defeat the byte-level round-trip
 // assertions in runner-file-args.test.ts.
 const mkdtemp = vi.fn(async () => '/tmp/gogcli-mcp-fake');
+const mkdir = vi.fn(async () => undefined);
 const writeFile = vi.fn(async () => {});
 const rm = vi.fn(async () => {});
 
 vi.mock('node:fs/promises', () => ({
   mkdtemp: (...args: unknown[]) => mkdtemp(...(args as [])),
+  mkdir: (...args: unknown[]) => mkdir(...(args as [])),
   writeFile: (...args: unknown[]) => writeFile(...(args as [])),
   rm: (...args: unknown[]) => rm(...(args as [])),
 }));
@@ -36,9 +38,11 @@ const fileArg = { kind: 'file', flag: 'body-file', contents: 'payload' } as cons
 describe('temp-file materialization failures', () => {
   beforeEach(() => {
     mkdtemp.mockClear();
+    mkdir.mockClear();
     writeFile.mockClear();
     rm.mockClear();
     rm.mockImplementation(async () => {});
+    mkdir.mockImplementation(async () => undefined);
     writeFile.mockImplementation(async () => {});
   });
 
@@ -83,12 +87,53 @@ describe('temp-file materialization failures', () => {
     await expect(run(['gmail', 'send', fileArg], { spawner })).rejects.toThrow('gog: invalid draft');
   });
 
-  it('writes the payload with mode 0600 and utf8 encoding', async () => {
+  it('writes the payload as owner-only utf8 bytes', async () => {
     await run(['gmail', 'send', fileArg], { spawner: okSpawner() });
     expect(writeFile).toHaveBeenCalledWith(
       expect.stringContaining('body-file.txt'),
-      'payload',
-      { encoding: 'utf8', mode: 0o600 },
+      Buffer.from('payload', 'utf8'),
+      { mode: 0o600 },
     );
+    // Each payload lands in its own numbered subdirectory of the temp dir, so a
+    // caller-chosen basename can never clobber another payload's.
+    expect(mkdir).toHaveBeenCalledWith('/tmp/gogcli-mcp-fake/0', { recursive: true, mode: 0o700 });
+  });
+
+  it('decodes a base64 payload to real bytes and honours a caller filename', async () => {
+    const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    await run([
+      'gmail', 'send',
+      { kind: 'file', flag: 'attach', contents: png.toString('base64'), encoding: 'base64', filename: 'Screenshot 2026-06-13 152500.png' },
+    ], { spawner: okSpawner() });
+    expect(writeFile).toHaveBeenCalledWith(
+      '/tmp/gogcli-mcp-fake/0/Screenshot 2026-06-13 152500.png',
+      png,
+      { mode: 0o600 },
+    );
+  });
+
+  it('gives each file arg its own subdirectory so identical basenames survive', async () => {
+    const spawner = okSpawner();
+    await run([
+      'gmail', 'send',
+      { kind: 'file', flag: 'attach', contents: 'YQ==', encoding: 'base64', filename: 'chart.png' },
+      { kind: 'file', flag: 'attach', contents: 'Yg==', encoding: 'base64', filename: 'chart.png' },
+    ], { spawner });
+    const written = writeFile.mock.calls.map((c) => c[0]);
+    expect(written).toEqual(['/tmp/gogcli-mcp-fake/0/chart.png', '/tmp/gogcli-mcp-fake/1/chart.png']);
+    // Both survive as distinct --attach values rather than one clobbering the other.
+    const argv = (spawner as unknown as { mock: { calls: [string, string[]][] } }).mock.calls[0][1];
+    expect(argv.filter((a) => a.startsWith('--attach='))).toHaveLength(2);
+  });
+
+  it('emits a positional file arg as a bare path, not --flag=path', async () => {
+    const spawner = okSpawner();
+    await run([
+      'drive', 'upload',
+      { kind: 'file', flag: 'localPath', contents: 'YQ==', encoding: 'base64', filename: 'notes.md', positional: true },
+    ], { spawner });
+    const argv = (spawner as unknown as { mock: { calls: [string, string[]][] } }).mock.calls[0][1];
+    expect(argv).toContain('/tmp/gogcli-mcp-fake/0/notes.md');
+    expect(argv.some((a) => a.startsWith('--localPath='))).toBe(false);
   });
 });

package/tests/runner.test.ts

@@ -592,6 +592,132 @@ describe('run', () => {
     expect(tokensOnly).not.toContain('[REDACTED]');
   });
 
+  // ==========================================================================
+  // BASE64 PAYLOAD SURVIVAL — the "Invalid Base64 string" defect.
+  //
+  // `1//` is spelled entirely in the base64 alphabet, so the refresh-token
+  // pattern used to match inside attachment bytes and eat forward to the next
+  // `+` or `/`. A 72 KiB PNG is ~97k base64 chars, giving ~0.37 expected `1//`
+  // runs — so roughly a THIRD of all attachments came back corrupt, and the
+  // client rejected them with an MCP -32602 "Invalid Base64 string".
+  //
+  // It looked filename-dependent because it is content-dependent and therefore
+  // uncorrelated with anything visible. These tests pin the real variable.
+  // ==========================================================================
+  const isValidBase64 = (s: string): boolean => Buffer.from(s, 'base64').toString('base64') === s;
+
+  it('leaves a base64 payload containing the refresh-token spelling intact', async () => {
+    // `1//` sitting mid-blob, preceded by base64 characters — the exact shape
+    // that used to be deleted.
+    const payload = `AAAA1//abcdefghijklmnop${'QRSTuvwx'.repeat(4)}`;
+    expect(payload).toContain('1//');
+    const spawner = makeSpawner(0, JSON.stringify({ contentBase64: payload }), '');
+    const out = await run(['gmail', 'attachment', 'm1', '0'], { spawner });
+    expect(JSON.parse(out).contentBase64).toBe(payload);
+    expect(out).not.toContain('[REDACTED]');
+  });
+
+  it('keeps every generated attachment payload valid base64 (the ~30% failure)', async () => {
+    // 200 payloads at the reported sizes. Before the fix ~30% of these came back
+    // undecodable; the assertion is that ALL of them survive, not most.
+    for (let i = 0; i < 200; i += 1) {
+      const bytes = Buffer.alloc(4096);
+      // Deterministic filler that still produces `1//` runs at the natural rate:
+      // a counter-driven byte pattern, seeded differently per iteration.
+      for (let b = 0; b < bytes.length; b += 1) bytes[b] = (b * 31 + i * 7) % 256;
+      const payload = bytes.toString('base64');
+      const spawner = makeSpawner(0, JSON.stringify({ contentBase64: payload }), '');
+      const out = await run(['gmail', 'attachment', 'm1', '0'], { spawner });
+      const got = JSON.parse(out).contentBase64 as string;
+      expect(isValidBase64(got)).toBe(true);
+      expect(got).toBe(payload);
+    }
+  });
+
+  // The left-boundary anchor must not narrow detection. Every character NOT in
+  // the standard base64 alphabet is a delimiter a real token turns up after, and
+  // `=` is the one that matters most: the form-encoded spelling is not covered by
+  // the shared redactor's query-param rule, which requires a preceding `?`/`&`.
+  it.each([
+    ['refresh_token=1//0eFORM-ENCODED-LEAK', '1//0eFORM-ENCODED-LEAK'],
+    ['access_token=ya29.a0FORM-ENCODED-LEAK', 'ya29.a0FORM-ENCODED-LEAK'],
+    ['grant:1//0eCOLON-LEAK', '1//0eCOLON-LEAK'],
+    ['[1//0eBRACKET-LEAK]', '1//0eBRACKET-LEAK'],
+    ['token is ya29.a0SPACE-LEAK', 'ya29.a0SPACE-LEAK'],
+  ])('redacts a token delimited by %j', async (stdout, secret) => {
+    const spawner = makeSpawner(0, stdout, '');
+    const out = await run(['auth', 'list'], { spawner });
+    expect(out).not.toContain(secret);
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it("redactMode 'tokens' also catches the form-encoded spelling", async () => {
+    // This path runs ONLY redactGoogleTokens, so the anchor is the whole defence.
+    const spawner = makeSpawner(0, 'refresh_token=1//0eTOKENS-MODE-LEAK', '');
+    const out = await run(['auth', 'add'], { spawner, redactMode: 'tokens' });
+    expect(out).not.toContain('1//0eTOKENS-MODE-LEAK');
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it('still redacts a real refresh token, which is never welded to base64', async () => {
+    // The anchor must not have bought base64 survival at the cost of detection:
+    // a genuine token is always delimited (quote, space, `=`, `:`), so it still
+    // matches.
+    const spawner = makeSpawner(0, '{"refresh_token":"1//0eREAL-REFRESH-TOKEN"}', '');
+    const out = await run(['auth', 'list'], { spawner });
+    expect(out).not.toContain('1//0eREAL-REFRESH-TOKEN');
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it('opaqueFields exempts a named blob from redaction it would otherwise fail', async () => {
+    // A payload that spells a Google API key by chance — still possible after
+    // the boundary anchor, because AIza… needs no delimiter. The field
+    // exemption is what covers this class rather than one pattern.
+    // `/` supplies the word boundary AIza… needs, and every character here is
+    // in the base64 alphabet — so this is a payload a real file can produce.
+    const payload = `AAAA/AIza${'B'.repeat(35)}/CCC`;
+    expect(Buffer.from(payload, 'base64').toString('base64')).toBe(payload); // genuinely valid base64
+    const spawner = makeSpawner(0, JSON.stringify({ contentBase64: payload }), '');
+    const bare = await run(['gmail', 'attachment', 'm1', '0'], { spawner });
+    expect(bare).toContain('[REDACTED]'); // unprotected, the shared redactor hits it
+
+    const spawner2 = makeSpawner(0, JSON.stringify({ contentBase64: payload }), '');
+    const guarded = await run(['gmail', 'attachment', 'm1', '0'], {
+      spawner: spawner2,
+      opaqueFields: ['contentBase64'],
+    });
+    expect(JSON.parse(guarded).contentBase64).toBe(payload);
+  });
+
+  it('opaqueFields still redacts prose OUTSIDE the exempt field', async () => {
+    // The exemption is per-field, not per-response: a token in a sibling field
+    // must still be stripped.
+    const stdout = JSON.stringify({
+      contentBase64: 'QUJDREVGR0hJSktMTU5PUFFSU1Q=',
+      note: 'refreshed with 1//0eLEAK-IN-PROSE',
+    });
+    const spawner = makeSpawner(0, stdout, '');
+    const out = await run(['gmail', 'attachment', 'm1', '0'], { spawner, opaqueFields: ['contentBase64'] });
+    expect(out).not.toContain('1//0eLEAK-IN-PROSE');
+    expect(JSON.parse(out).contentBase64).toBe('QUJDREVGR0hJSktMTU5PUFFSU1Q=');
+  });
+
+  it('opaqueFields does not exempt a field carrying prose rather than a blob', async () => {
+    // Only an all-base64 value qualifies, so naming a field cannot be used to
+    // smuggle a credential through in a sentence.
+    const stdout = JSON.stringify({ contentBase64: 'token is 1//0eSMUGGLED-TOKEN here' });
+    const spawner = makeSpawner(0, stdout, '');
+    const out = await run(['gmail', 'attachment', 'm1', '0'], { spawner, opaqueFields: ['contentBase64'] });
+    expect(out).not.toContain('1//0eSMUGGLED-TOKEN');
+  });
+
+  it('opaqueFields never exempts anything on the ERROR path', async () => {
+    const spawner = makeSpawner(1, '', 'failed for 1//0eERROR-PATH-LEAK');
+    await expect(
+      run(['gmail', 'attachment', 'm1', '0'], { spawner, opaqueFields: ['contentBase64'] }),
+    ).rejects.toThrow(/\[REDACTED\]/);
+  });
+
   it("redactMode 'tokens' still strips real Google tokens", async () => {
     const leak = 'url with token ya29.a0Ad52N3-STEP-LEAK and refresh 1//0eSTEP-REFRESH-LEAK';
     const spawner = makeSpawner(0, leak, '');

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 },
+    );
+  });
+});