gogcli-mcp 2.23.2 → 2.25.0

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/tools/auth.test.ts

@@ -124,6 +124,35 @@ describe('gog_auth_add', () => {
     );
   });
 
+  // gog 0.37.0's Connected Sheets reads need bigquery.readonly, which no
+  // `services` selection covers. --force-consent is not optional alongside it:
+  // Google re-prompts for a NEW scope only when consent is forced, so without
+  // it the grant can come back missing the scope AND reporting success.
+  it('passes --extra-scopes with --force-consent', async () => {
+    vi.mocked(runner.run).mockResolvedValue('Authorization successful');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_auth_add', {
+      email: 'user@gmail.com',
+      services: 'sheets',
+      extraScopes: 'https://www.googleapis.com/auth/bigquery.readonly',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['auth', 'add', 'user@gmail.com', '--services', 'sheets',
+        '--extra-scopes=https://www.googleapis.com/auth/bigquery.readonly', '--force-consent'],
+      { interactive: true, timeout: 300_000 },
+    );
+  });
+
+  it('does not force consent when no extra scopes are asked for', async () => {
+    vi.mocked(runner.run).mockResolvedValue('Authorization successful');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_auth_add', { email: 'user@gmail.com' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['auth', 'add', 'user@gmail.com', '--services', 'all'],
+      { interactive: true, timeout: 300_000 },
+    );
+  });
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Auth cancelled by user'));
     const harness = await setupHandlers();
@@ -215,6 +244,21 @@ describe('gog_auth_add_url', () => {
     );
   });
 
+  it('appends --extra-scopes after the service scopes', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"auth_url":"https://x"}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_auth_add_url', {
+      email: 'user@gmail.com',
+      services: 'sheets',
+      extraScopes: 'https://www.googleapis.com/auth/bigquery.readonly',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['auth', 'add', 'user@gmail.com', '--remote', '--step', '1', '--services', 'sheets', '--force-consent',
+        '--extra-scopes=https://www.googleapis.com/auth/bigquery.readonly'],
+      { redactMode: 'tokens' },
+    );
+  });
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('client not configured'));
     const harness = await setupHandlers();
@@ -252,6 +296,22 @@ describe('gog_auth_add_complete', () => {
     );
   });
 
+  it('carries the same --extra-scopes as step 1', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"stored":true}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_auth_add_complete', {
+      email: 'user@gmail.com',
+      redirectUrl: 'http://127.0.0.1/cb?code=c&state=s',
+      services: 'sheets',
+      extraScopes: 'https://www.googleapis.com/auth/bigquery.readonly',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['auth', 'add', 'user@gmail.com', '--remote', '--step', '2', '--auth-url',
+        'http://127.0.0.1/cb?code=c&state=s', '--services', 'sheets', '--force-consent',
+        '--extra-scopes=https://www.googleapis.com/auth/bigquery.readonly'],
+    );
+  });
+
   it('returns error text on failure (e.g. expired state)', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('no matching manual auth state'));
     const harness = await setupHandlers();

package/tests/tools/calendar.test.ts

@@ -17,23 +17,50 @@ describe('gog_calendar_events', () => {
     expect(runner.run).toHaveBeenCalledWith(['calendar', 'events'], { account: undefined });
   });
 
-  it('appends calendarId and filters when provided', async () => {
+  // The window flags are pinned as SEPARATE cases on purpose: gog >= 0.36.0
+  // (openclaw/gogcli#981) rejects a fixed preset combined with from/to/days,
+  // and days combined with to, so one test passing them all at once would
+  // assert an arg array gog refuses to run.
+  it('appends calendarId and an explicit from/to range', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', {
       calendarId: 'primary',
       from: '2026-01-01',
       to: '2026-01-31',
-      today: true,
       query: 'standup',
       all: true,
     });
     expect(runner.run).toHaveBeenCalledWith(
-      ['calendar', 'events', 'primary', '--from=2026-01-01', '--to=2026-01-31', '--today', '--query=standup', '--all'],
+      ['calendar', 'events', 'primary', '--from=2026-01-01', '--to=2026-01-31', '--query=standup', '--all'],
       { account: undefined },
     );
   });
 
+  it('appends --today on its own', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_events', { today: true });
+    expect(runner.run).toHaveBeenCalledWith(['calendar', 'events', '--today'], { account: undefined });
+  });
+
+  it('anchors --days at --from when both are given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_events', { from: '2026-09-25', days: 5 });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'events', '--from=2026-09-25', '--days=5'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --days alone as a today-anchored window', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_events', { days: 7 });
+    expect(runner.run).toHaveBeenCalledWith(['calendar', 'events', '--days=7'], { account: undefined });
+  });
+
   it('repeats --event-types for each requested type', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();

package/tests/tools/gmail.test.ts

@@ -201,6 +201,23 @@ describe('gog_gmail_get', () => {
     expect(runner.run).toHaveBeenCalledWith(['gmail', 'get', 'msg1', '--format=metadata'], { account: undefined });
   });
 
+  // gog >= 0.37.0 (openclaw/gogcli#992): before that release the sanitized
+  // JSON repeated the headers and body at the top level, so this flag grew the
+  // payload it exists to shrink. Pinned here as the flag spelling gog expects.
+  it('appends --sanitize-content when asked', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_gmail_get', { messageId: 'msg1', sanitizeContent: true });
+    expect(runner.run).toHaveBeenCalledWith(['gmail', 'get', 'msg1', '--sanitize-content'], { account: undefined });
+  });
+
+  it('omits --sanitize-content when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_gmail_get', { messageId: 'msg1', sanitizeContent: false });
+    expect(runner.run).toHaveBeenCalledWith(['gmail', 'get', 'msg1'], { account: undefined });
+  });
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Not found'));
     const harness = await setupHandlers();
@@ -262,6 +279,95 @@ describe('gog_gmail_send', () => {
     );
   });
 
+  // ==========================================================================
+  // INLINE ATTACHMENT BYTES — for callers with no filesystem in common with gog
+  // (the hosted connector, any GOG_RUNNER_URL backend). The bytes ride with the
+  // call and the executor materializes them beside gog.
+  // ==========================================================================
+  it('turns attachInline bytes into repeatable --attach file args', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    const png = Buffer.from([0x89, 0x50, 0x4e, 0x47]).toString('base64');
+    await harness.callTool('gog_gmail_send', {
+      to: 'bob@example.com',
+      subject: 'Layouts',
+      body: 'See attached',
+      attachInline: [{ filename: 'pendant-layouts.png', contentBase64: png }],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      [
+        'gmail', 'send',
+        '--to=bob@example.com', '--subject=Layouts', '--body=See attached',
+        { kind: 'file', flag: 'attach', contents: png, encoding: 'base64', filename: 'pendant-layouts.png' },
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('combines server-side paths and inline bytes on one message', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    const bytes = Buffer.from('hello').toString('base64');
+    await harness.callTool('gog_gmail_send', {
+      to: 'bob@example.com',
+      subject: 'Both',
+      body: 'x',
+      attach: ['/tmp/on-server.pdf'],
+      attachInline: [{ filename: 'from-client.txt', contentBase64: bytes }],
+    });
+    const args = vi.mocked(runner.run).mock.calls[0][0];
+    expect(args).toContain('--attach=/tmp/on-server.pdf');
+    expect(args).toContainEqual(
+      { kind: 'file', flag: 'attach', contents: bytes, encoding: 'base64', filename: 'from-client.txt' },
+    );
+  });
+
+  it('keeps a filename with spaces and non-ASCII intact end to end', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    const filename = 'Reçu — étude 2026.png';
+    await harness.callTool('gog_gmail_send', {
+      to: 'bob@example.com', subject: 's', body: 'b',
+      attachInline: [{ filename, contentBase64: Buffer.from('x').toString('base64') }],
+    });
+    const args = vi.mocked(runner.run).mock.calls[0][0];
+    expect(args.at(-1)).toMatchObject({ filename });
+  });
+
+  it('surfaces an invalid-base64 attachment as a readable error, not a corrupt send', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    const res = await harness.callTool('gog_gmail_send', {
+      to: 'bob@example.com', subject: 's', body: 'b',
+      attachInline: [{ filename: 'a.png', contentBase64: 'not!valid!base64!' }],
+    });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toMatch(/not valid base64/);
+    expect(runner.run).not.toHaveBeenCalled(); // nothing was sent
+  });
+
+  it('rejects an oversize attachment before the call rather than deep in the stack', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    const res = await harness.callTool('gog_gmail_send', {
+      to: 'bob@example.com', subject: 's', body: 'b',
+      attachInline: [{ filename: 'huge.bin', contentBase64: Buffer.alloc(8 * 1024 * 1024 + 1).toString('base64') }],
+    });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toMatch(/per-file limit/);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('leaves the arg list untouched when attachInline is absent', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_gmail_send', { to: 'b@e.com', subject: 'Hi', body: 'Hello' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['gmail', 'send', '--to=b@e.com', '--subject=Hi', '--body=Hello'],
+      { account: undefined },
+    );
+  });
+
   // A body over the shared threshold cannot ride in argv (the hosted runner
   // caps a single arg; Linux caps MAX_ARG_STRLEN at 128 KiB), so payloadArg
   // swaps it for a file arg the executor materializes as a temp file.