gogcli-mcp-gmail 2.0.3

package/tests/tools/gmail-extra.test.ts

@@ -0,0 +1,606 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerExtraGmailTools } from '../../src/tools/gmail-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return {
+    ...actual,
+    runOrDiagnose: vi.fn(),
+  };
+});
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+function toText(text: string) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function setupHandlers(): Map<string, ToolHandler> {
+  const server = new McpServer({ name: 'test', version: '0.0.0' });
+  const handlers = new Map<string, ToolHandler>();
+  vi.spyOn(server, 'registerTool').mockImplementation((name, _config, cb) => {
+    handlers.set(name, cb as ToolHandler);
+    return undefined as never;
+  });
+  registerExtraGmailTools(server);
+  return handlers;
+}
+
+let handlers: Map<string, ToolHandler>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+  handlers = setupHandlers();
+});
+
+describe('gog_gmail_raw', () => {
+  it('calls runOrDiagnose with messageId', async () => {
+    await handlers.get('gog_gmail_raw')!({ messageId: 'm1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined });
+  });
+
+  it('passes --format and --pretty when provided', async () => {
+    await handlers.get('gog_gmail_raw')!({ messageId: 'm1', format: 'metadata', pretty: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'raw', 'm1', '--format=metadata', '--pretty'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --pretty when false', async () => {
+    await handlers.get('gog_gmail_raw')!({ messageId: 'm1', pretty: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'raw', 'm1'], { account: undefined });
+  });
+});
+
+describe('gog_gmail_attachment', () => {
+  it('calls runOrDiagnose with messageId and attachmentId', async () => {
+    await handlers.get('gog_gmail_attachment')!({ messageId: 'm1', attachmentId: 'a1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'attachment', 'm1', 'a1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --out and --name when provided', async () => {
+    await handlers.get('gog_gmail_attachment')!({
+      messageId: 'm1',
+      attachmentId: 'a1',
+      out: '/tmp/file.pdf',
+      name: 'report.pdf',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'attachment', 'm1', 'a1', '--out=/tmp/file.pdf', '--name=report.pdf'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_url', () => {
+  it('calls runOrDiagnose with a single threadId', async () => {
+    await handlers.get('gog_gmail_url')!({ threadIds: ['t1'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'url', 't1'], { account: undefined });
+  });
+
+  it('calls runOrDiagnose with multiple threadIds', async () => {
+    await handlers.get('gog_gmail_url')!({ threadIds: ['t1', 't2', 't3'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'url', 't1', 't2', 't3'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_history', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_history')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'history'], { account: undefined });
+  });
+
+  it('passes all history flags', async () => {
+    await handlers.get('gog_gmail_history')!({ since: '12345', max: 50, page: 'tok', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'history', '--since=12345', '--max=50', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_gmail_history')!({ all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['gmail', 'history'], { account: undefined });
+  });
+});
+
+describe('bulk action tools (archive, mark_read, mark_unread, trash)', () => {
+  const bulkTools = [
+    { tool: 'gog_gmail_archive', cmd: 'archive' },
+    { tool: 'gog_gmail_mark_read', cmd: 'mark-read' },
+    { tool: 'gog_gmail_mark_unread', cmd: 'unread' },
+    { tool: 'gog_gmail_trash', cmd: 'trash' },
+  ];
+
+  for (const { tool, cmd } of bulkTools) {
+    describe(tool, () => {
+      it('passes messageIds as positional args', async () => {
+        await handlers.get(tool)!({ messageIds: ['m1', 'm2'] });
+        expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+          ['gmail', cmd, 'm1', 'm2'],
+          { account: undefined },
+        );
+      });
+
+      it('passes --query and --max', async () => {
+        await handlers.get(tool)!({ query: 'is:unread older_than:7d', max: 50 });
+        expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+          ['gmail', cmd, '--query=is:unread older_than:7d', '--max=50'],
+          { account: undefined },
+        );
+      });
+
+      it('passes both positional ids and flags together', async () => {
+        await handlers.get(tool)!({ messageIds: ['m1'], max: 10 });
+        expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+          ['gmail', cmd, 'm1', '--max=10'],
+          { account: undefined },
+        );
+      });
+    });
+  }
+});
+
+describe('gog_gmail_message_modify', () => {
+  it('calls runOrDiagnose with messageId and label changes', async () => {
+    await handlers.get('gog_gmail_message_modify')!({
+      messageId: 'm1',
+      add: 'STARRED,IMPORTANT',
+      remove: 'INBOX',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'modify', 'm1', '--add=STARRED,IMPORTANT', '--remove=INBOX'],
+      { account: undefined },
+    );
+  });
+
+  it('omits flags when not provided', async () => {
+    await handlers.get('gog_gmail_message_modify')!({ messageId: 'm1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'modify', 'm1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_batch_delete', () => {
+  it('calls runOrDiagnose with messageIds as positional args', async () => {
+    await handlers.get('gog_gmail_batch_delete')!({ messageIds: ['m1', 'm2', 'm3'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'batch', 'delete', 'm1', 'm2', 'm3'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_batch_modify', () => {
+  it('calls runOrDiagnose with messageIds and label flags', async () => {
+    await handlers.get('gog_gmail_batch_modify')!({
+      messageIds: ['m1', 'm2'],
+      add: 'STARRED',
+      remove: 'INBOX',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'batch', 'modify', 'm1', 'm2', '--add=STARRED', '--remove=INBOX'],
+      { account: undefined },
+    );
+  });
+
+  it('omits label flags when not provided', async () => {
+    await handlers.get('gog_gmail_batch_modify')!({ messageIds: ['m1'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'batch', 'modify', 'm1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_thread_get', () => {
+  it('calls runOrDiagnose with threadId', async () => {
+    await handlers.get('gog_gmail_thread_get')!({ threadId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'get', 't1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_gmail_thread_get')!({
+      threadId: 't1',
+      download: true,
+      full: true,
+      sanitizeContent: true,
+      outDir: '/tmp/atts',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'get', 't1', '--download', '--full', '--sanitize-content', '--out-dir=/tmp/atts'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_thread_get')!({
+      threadId: 't1',
+      download: false,
+      full: false,
+      sanitizeContent: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'get', 't1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_thread_modify', () => {
+  it('calls runOrDiagnose with threadId and label flags', async () => {
+    await handlers.get('gog_gmail_thread_modify')!({
+      threadId: 't1',
+      add: 'IMPORTANT',
+      remove: 'INBOX',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'modify', 't1', '--add=IMPORTANT', '--remove=INBOX'],
+      { account: undefined },
+    );
+  });
+
+  it('omits label flags when not provided', async () => {
+    await handlers.get('gog_gmail_thread_modify')!({ threadId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'modify', 't1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_thread_attachments', () => {
+  it('calls runOrDiagnose with threadId', async () => {
+    await handlers.get('gog_gmail_thread_attachments')!({ threadId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'attachments', 't1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --download and --out-dir when provided', async () => {
+    await handlers.get('gog_gmail_thread_attachments')!({
+      threadId: 't1',
+      download: true,
+      outDir: '/tmp/atts',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'thread', 'attachments', 't1', '--download', '--out-dir=/tmp/atts'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_list', () => {
+  it('calls runOrDiagnose with no args', async () => {
+    await handlers.get('gog_gmail_labels_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'list'],
+      { account: undefined },
+    );
+  });
+
+  it('forwards account', async () => {
+    await handlers.get('gog_gmail_labels_list')!({ account: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'list'],
+      { account: 'a@b.com' },
+    );
+  });
+});
+
+describe('gog_gmail_labels_get', () => {
+  it('calls runOrDiagnose with labelIdOrName', async () => {
+    await handlers.get('gog_gmail_labels_get')!({ labelIdOrName: 'INBOX' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'get', 'INBOX'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_create', () => {
+  it('calls runOrDiagnose with name', async () => {
+    await handlers.get('gog_gmail_labels_create')!({ name: 'Newsletter' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'create', 'Newsletter'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_rename', () => {
+  it('calls runOrDiagnose with old and new names', async () => {
+    await handlers.get('gog_gmail_labels_rename')!({ labelIdOrName: 'Old', newName: 'New' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'rename', 'Old', 'New'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_delete', () => {
+  it('calls runOrDiagnose with labelIdOrName', async () => {
+    await handlers.get('gog_gmail_labels_delete')!({ labelIdOrName: 'Trash-Me' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'delete', 'Trash-Me'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_modify', () => {
+  it('calls runOrDiagnose with threadIds and label flags', async () => {
+    await handlers.get('gog_gmail_labels_modify')!({
+      threadIds: ['t1', 't2'],
+      add: 'Newsletter',
+      remove: 'INBOX',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'modify', 't1', 't2', '--add=Newsletter', '--remove=INBOX'],
+      { account: undefined },
+    );
+  });
+
+  it('omits label flags when not provided', async () => {
+    await handlers.get('gog_gmail_labels_modify')!({ threadIds: ['t1'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'modify', 't1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_list', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_drafts_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'list'],
+      { account: undefined },
+    );
+  });
+
+  it('passes pagination flags', async () => {
+    await handlers.get('gog_gmail_drafts_list')!({ max: 50, page: 'tok', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'list', '--max=50', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_get', () => {
+  it('calls runOrDiagnose with draftId', async () => {
+    await handlers.get('gog_gmail_drafts_get')!({ draftId: 'd1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'get', 'd1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --download when true', async () => {
+    await handlers.get('gog_gmail_drafts_get')!({ draftId: 'd1', download: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'get', 'd1', '--download'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_create', () => {
+  it('calls runOrDiagnose with minimal required flags', async () => {
+    await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'Hi',
+      body: 'Hello',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags including attachments', async () => {
+    await handlers.get('gog_gmail_drafts_create')!({
+      to: 'a@b.com,c@d.com',
+      cc: 'cc@x.com',
+      bcc: 'bcc@x.com',
+      subject: 'Hi',
+      body: 'Hello',
+      bodyHtml: '<p>Hi</p>',
+      replyToMessageId: 'm1',
+      replyTo: 'rt@x.com',
+      quote: true,
+      attach: ['/tmp/a.pdf', '/tmp/b.pdf'],
+      from: 'me@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'drafts', 'create',
+        '--to=a@b.com,c@d.com',
+        '--cc=cc@x.com',
+        '--bcc=bcc@x.com',
+        '--subject=Hi',
+        '--body=Hello',
+        '--body-html=<p>Hi</p>',
+        '--reply-to-message-id=m1',
+        '--reply-to=rt@x.com',
+        '--quote',
+        '--attach=/tmp/a.pdf',
+        '--attach=/tmp/b.pdf',
+        '--from=me@x.com',
+      ],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_update', () => {
+  it('calls runOrDiagnose with draftId and updated fields', async () => {
+    await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1',
+      subject: 'New subject',
+      body: 'New body',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=New subject', '--body=New body'],
+      { account: undefined },
+    );
+  });
+
+  it('passes attachments as repeatable flags', async () => {
+    await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1',
+      subject: 'S',
+      body: 'B',
+      attach: ['/tmp/x.pdf'],
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B', '--attach=/tmp/x.pdf'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_delete', () => {
+  it('calls runOrDiagnose with draftId', async () => {
+    await handlers.get('gog_gmail_drafts_delete')!({ draftId: 'd1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'delete', 'd1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_drafts_send', () => {
+  it('calls runOrDiagnose with draftId', async () => {
+    await handlers.get('gog_gmail_drafts_send')!({ draftId: 'd1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'send', 'd1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_forward', () => {
+  it('calls runOrDiagnose with messageId and required --to', async () => {
+    await handlers.get('gog_gmail_forward')!({ messageId: 'm1', to: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'forward', 'm1', '--to=a@b.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all forward flags', async () => {
+    await handlers.get('gog_gmail_forward')!({
+      messageId: 'm1',
+      to: 'a@b.com',
+      cc: 'cc@x.com',
+      bcc: 'bcc@x.com',
+      note: 'FYI',
+      from: 'me@x.com',
+      skipAttachments: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'forward', 'm1',
+        '--to=a@b.com',
+        '--cc=cc@x.com',
+        '--bcc=bcc@x.com',
+        '--note=FYI',
+        '--from=me@x.com',
+        '--skip-attachments',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits --skip-attachments when false', async () => {
+    await handlers.get('gog_gmail_forward')!({ messageId: 'm1', to: 'a@b.com', skipAttachments: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'forward', 'm1', '--to=a@b.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_autoreply', () => {
+  it('calls runOrDiagnose with query and --body', async () => {
+    await handlers.get('gog_gmail_autoreply')!({ query: 'is:unread', body: 'Thanks' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'autoreply', 'is:unread', '--body=Thanks'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all autoreply flags', async () => {
+    await handlers.get('gog_gmail_autoreply')!({
+      query: 'is:unread',
+      max: 50,
+      subject: 'Re: out of office',
+      body: 'I am out',
+      bodyHtml: '<p>OOO</p>',
+      from: 'me@x.com',
+      replyTo: 'rt@x.com',
+      label: 'OOO-Replied',
+      archive: true,
+      markRead: true,
+      skipBulk: true,
+      allowSelf: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'gmail', 'autoreply', 'is:unread',
+        '--max=50',
+        '--subject=Re: out of office',
+        '--body=I am out',
+        '--body-html=<p>OOO</p>',
+        '--from=me@x.com',
+        '--reply-to=rt@x.com',
+        '--label=OOO-Replied',
+        '--archive',
+        '--mark-read',
+        '--skip-bulk',
+        '--allow-self',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_autoreply')!({
+      query: 'is:unread',
+      body: 'Thanks',
+      archive: false,
+      markRead: false,
+      skipBulk: false,
+      allowSelf: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'autoreply', 'is:unread', '--body=Thanks'],
+      { account: undefined },
+    );
+  });
+
+  it('supports HTML-only body (no plain --body)', async () => {
+    await handlers.get('gog_gmail_autoreply')!({ query: 'is:unread', bodyHtml: '<p>Hi</p>' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'autoreply', 'is:unread', '--body-html=<p>Hi</p>'],
+      { account: undefined },
+    );
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "../"
+  },
+  "include": ["src/**/*", "../gogcli-mcp/src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/index.ts'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+    },
+  },
+});