gogcli-mcp 2.0.11 → 2.2.0

package/tests/tools/sheets.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerSheetsTools } from '../../src/tools/sheets.js';
 import * as runner from '../../src/runner.js';
 import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
@@ -84,6 +85,135 @@ describe('gog_sheets_update', () => {
     const result = await handlers.get('gog_sheets_update')!({ spreadsheetId: 'bad', range: 'A1', values: [['x']] });
     expect(result.content[0].text).toBe('Error: Update failed');
   });
+
+  it('appends --dry-run when dry_run is true', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"dryRun":true}');
+    const handlers = setupHandlers();
+    const values = [['x']];
+    await handlers.get('gog_sheets_update')!({ spreadsheetId: 'sid', range: 'A1', values, dry_run: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['sheets', 'update', 'sid', 'A1', `--values-json=${JSON.stringify(values)}`, '--dry-run'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --dry-run when dry_run is false or unset', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update')!({ spreadsheetId: 'sid', range: 'A1', values: [['x']], dry_run: false });
+    expect(vi.mocked(runner.run).mock.calls[0]![0]).not.toContain('--dry-run');
+  });
+});
+
+describe('gog_sheets_update fail_if_not_empty guard', () => {
+  it('aborts the write when the target range already holds data', async () => {
+    vi.mocked(runner.run).mockResolvedValueOnce('{"values":[["existing"]]}');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [['new']], fail_if_not_empty: true,
+    });
+    // Only the read happened — no update call.
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(runner.run).toHaveBeenCalledWith(['sheets', 'get', 'sid', 'A1:A1'], { account: undefined });
+    expect(result.content[0].text).toContain('Write aborted');
+    expect(result.content[0].text).toContain('A1:A1');
+    expect(result.content[0].text).toContain('1 cell');
+  });
+
+  it('proceeds with the write when the target range is empty', async () => {
+    vi.mocked(runner.run)
+      .mockResolvedValueOnce('{}')
+      .mockResolvedValueOnce('{"updatedCells":1}');
+    const handlers = setupHandlers();
+    const values = [['new']];
+    const result = await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values, fail_if_not_empty: true,
+    });
+    expect(runner.run).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(runner.run).mock.calls[1]![0]).toEqual(
+      ['sheets', 'update', 'sid', 'A1', `--values-json=${JSON.stringify(values)}`],
+    );
+    expect(result.content[0].text).toBe('{"updatedCells":1}');
+  });
+
+  it('expands an anchor cell to the full written area before reading', async () => {
+    vi.mocked(runner.run)
+      .mockResolvedValueOnce('{}')
+      .mockResolvedValueOnce('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'Sheet1!A1',
+      values: [['a', 'b'], ['c', 'd'], ['e', 'f']], fail_if_not_empty: true,
+    });
+    expect(vi.mocked(runner.run).mock.calls[0]![0]).toEqual(['sheets', 'get', 'sid', 'Sheet1!A1:B3']);
+  });
+
+  it('aborts without writing and diagnoses the error when the verification read fails', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('read boom')) // the verification get
+      .mockResolvedValueOnce('{"accounts":[{"email":"u@x.com"}]}'); // diagnose -> auth list
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [['new']], fail_if_not_empty: true,
+    });
+    // get + auth list (for diagnosis), but the update is never attempted
+    expect(runner.run).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(runner.run).mock.calls.some((c) => c[0][1] === 'update')).toBe(false);
+    expect(result.content[0].text).toContain('Error: read boom');
+    expect(result.content[0].text).toContain('Configured accounts:');
+  });
+
+  it('surfaces the re-auth hint when the verification read fails with an auth error', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Request failed with status 401'))
+      .mockResolvedValueOnce('{"accounts":[{"email":"u@x.com"}]}');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [['x']], fail_if_not_empty: true,
+    });
+    expect(result.content[0].text).toContain('gog_auth_add');
+  });
+
+  it('aborts when emptiness cannot be verified from unparseable output', async () => {
+    vi.mocked(runner.run).mockResolvedValueOnce('not json');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [['new']], fail_if_not_empty: true,
+    });
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toContain('could not be verified');
+  });
+
+  it('still honors dry_run after the guard passes', async () => {
+    vi.mocked(runner.run)
+      .mockResolvedValueOnce('{}')
+      .mockResolvedValueOnce('{"dryRun":true}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [['new']], fail_if_not_empty: true, dry_run: true,
+    });
+    expect(vi.mocked(runner.run).mock.calls[1]![0]).toContain('--dry-run');
+  });
+
+  it('skips the guard read when values has no rows', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [], fail_if_not_empty: true,
+    });
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(runner.run).mock.calls[0]![0]![1]).toBe('update');
+  });
+
+  it('skips the guard read when rows have no columns', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update')!({
+      spreadsheetId: 'sid', range: 'A1', values: [[]], fail_if_not_empty: true,
+    });
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(runner.run).mock.calls[0]![0]![1]).toBe('update');
+  });
 });
 
 describe('gog_sheets_append', () => {
@@ -104,6 +234,17 @@ describe('gog_sheets_append', () => {
     const result = await handlers.get('gog_sheets_append')!({ spreadsheetId: 'bad', range: 'A1', values: [['x']] });
     expect(result.content[0].text).toBe('Error: Append failed');
   });
+
+  it('appends --dry-run when dry_run is true', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"dryRun":true}');
+    const handlers = setupHandlers();
+    const values = [['x']];
+    await handlers.get('gog_sheets_append')!({ spreadsheetId: 'sid', range: 'Sheet1!A:A', values, dry_run: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['sheets', 'append', 'sid', 'Sheet1!A:A', `--values-json=${JSON.stringify(values)}`, '--dry-run'],
+      { account: undefined },
+    );
+  });
 });
 
 describe('gog_sheets_clear', () => {
@@ -120,9 +261,30 @@ describe('gog_sheets_clear', () => {
     const result = await handlers.get('gog_sheets_clear')!({ spreadsheetId: 'bad', range: 'A1' });
     expect(result.content[0].text).toBe('Error: Clear failed');
   });
+
+  it('appends --dry-run when dry_run is true', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"dryRun":true}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_clear')!({ spreadsheetId: 'sid', range: 'Sheet1!A1:Z100', dry_run: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['sheets', 'clear', 'sid', 'Sheet1!A1:Z100', '--dry-run'],
+      { account: undefined },
+    );
+  });
 });
 
 describe('gog_sheets_metadata', () => {
+  it('advertises grid dimensions in its description', () => {
+    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;
+    });
+    registerSheetsTools(server);
+    expect(configs.get('gog_sheets_metadata')!.description).toMatch(/grid dimensions|rowCount|columnCount/i);
+  });
+
   it('calls run with spreadsheetId only', async () => {
     vi.mocked(runner.run).mockResolvedValue('{"title":"My Sheet","sheets":[{"title":"Sheet1"}]}');
     const handlers = setupHandlers();

package/tests/tools/utils.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as runner from '../../src/runner.js';
-import { runOrDiagnose, pushPaginationFlags } from '../../src/tools/utils.js';
+import { runOrDiagnose, pushPaginationFlags, formatAccountList } from '../../src/tools/utils.js';
 
 vi.mock('../../src/runner.js');
 
@@ -40,6 +40,53 @@ describe('pushPaginationFlags', () => {
   });
 });
 
+describe('formatAccountList', () => {
+  const AUTH_LIST_JSON = JSON.stringify({
+    accounts: [
+      {
+        email: 'chris.c.hall@gmail.com',
+        subject: '109876543210987654321',
+        client: 'default',
+        services: ['gmail', 'drive'],
+        scopes: ['https://www.googleapis.com/auth/gmail.modify', 'https://www.googleapis.com/auth/drive'],
+        created_at: '2026-01-02T03:04:05Z',
+      },
+    ],
+  });
+
+  it('reduces gog auth list JSON to email addresses only', () => {
+    const out = formatAccountList(AUTH_LIST_JSON);
+    expect(out).toBe('chris.c.hall@gmail.com');
+    // none of the sensitive fields leak through
+    expect(out).not.toContain('scopes');
+    expect(out).not.toContain('gmail.modify');
+    expect(out).not.toContain('109876543210987654321');
+    expect(out).not.toContain('created_at');
+  });
+
+  it('joins multiple account emails with newlines', () => {
+    const out = formatAccountList(JSON.stringify({ accounts: [{ email: 'a@x.com' }, { email: 'b@y.com' }] }));
+    expect(out).toBe('a@x.com\nb@y.com');
+  });
+
+  it('skips accounts with no email', () => {
+    const out = formatAccountList(JSON.stringify({ accounts: [{ email: 'a@x.com' }, { client: 'other' }] }));
+    expect(out).toBe('a@x.com');
+  });
+
+  it('falls back to the trimmed raw text when not parseable JSON', () => {
+    expect(formatAccountList('  user@gmail.com\n')).toBe('user@gmail.com');
+  });
+
+  it('falls back to raw text when JSON has no accounts array', () => {
+    expect(formatAccountList('{"foo":1}')).toBe('{"foo":1}');
+  });
+
+  it('falls back to raw text when parsed JSON is null', () => {
+    expect(formatAccountList('null')).toBe('null');
+  });
+});
+
 describe('runOrDiagnose', () => {
   it('returns output text on success', async () => {
     vi.mocked(runner.run).mockResolvedValue('{"ok":true}');
@@ -58,6 +105,35 @@ describe('runOrDiagnose', () => {
     expect(result.content[0].text).not.toContain('gog_auth_add');
   });
 
+  it('redacts scopes/subject/timestamps from the configured-accounts block', async () => {
+    const authListJson = JSON.stringify({
+      accounts: [{
+        email: 'chris.c.hall@gmail.com',
+        subject: '109876543210987654321',
+        scopes: ['https://www.googleapis.com/auth/gmail.modify'],
+        created_at: '2026-01-02T03:04:05Z',
+      }],
+    });
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('refusing to delete gmail draft r123 without --force (non-interactive)'))
+      .mockResolvedValueOnce(authListJson);
+    const result = await runOrDiagnose(['gmail', 'drafts', 'delete', 'r123'], {});
+    const text = result.content[0].text;
+    expect(text).toContain('Configured accounts:\nchris.c.hall@gmail.com');
+    expect(text).not.toContain('scopes');
+    expect(text).not.toContain('gmail.modify');
+    expect(text).not.toContain('109876543210987654321');
+    expect(text).not.toContain('created_at');
+  });
+
+  it('shows (none) when no accounts are configured', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Doc not found'))
+      .mockResolvedValueOnce('{"accounts":[]}');
+    const result = await runOrDiagnose(['docs', 'cat', 'abc'], {});
+    expect(result.content[0].text).toBe('Error: Doc not found\n\nConfigured accounts:\n(none)');
+  });
+
   it('appends re-auth hint on 401 error', async () => {
     vi.mocked(runner.run)
       .mockRejectedValueOnce(new Error('Request failed with status 401'))
@@ -175,4 +251,30 @@ describe('runOrDiagnose', () => {
     expect(result.content[0].text).toContain('transient');
     expect(result.content[0].text).not.toContain('Configured accounts');
   });
+
+  it('appends grid-limit hint pointing at gog_sheets_insert', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Range (Sheet1!AP1:AW1) exceeds grid limits. Max rows: 1000, max columns: 41'))
+      .mockResolvedValueOnce('user@gmail.com');
+    const result = await runOrDiagnose(['sheets', 'update', 'abc', 'AP1'], {});
+    expect(result.content[0].text).toContain('exceeds grid limits');
+    expect(result.content[0].text).toContain('gog_sheets_insert');
+  });
+
+  it('does not append grid-limit hint on unrelated errors', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Spreadsheet not found'))
+      .mockResolvedValueOnce('user@gmail.com');
+    const result = await runOrDiagnose(['sheets', 'update', 'abc', 'A1'], {});
+    expect(result.content[0].text).not.toContain('gog_sheets_insert');
+  });
+
+  it('keeps grid-limit hint when auth list also fails', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('exceeds grid limits. Max rows: 1000, max columns: 41'))
+      .mockRejectedValueOnce(new Error('auth list failed'));
+    const result = await runOrDiagnose(['sheets', 'update', 'abc', 'A1'], {});
+    expect(result.content[0].text).toContain('gog_sheets_insert');
+    expect(result.content[0].text).not.toContain('Configured accounts');
+  });
 });