gogcli-mcp-gmail 2.0.12 → 2.3.0

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

@@ -223,6 +223,72 @@ describe('gog_gmail_thread_get', () => {
       { account: undefined },
     );
   });
+
+  const THREAD = JSON.stringify({
+    downloaded: false,
+    thread: {
+      id: 't1',
+      messages: [
+        { id: 'm1', threadId: 't1', internalDate: '1', labelIds: ['INBOX'], snippet: 'first', payload: { headers: [{ name: 'From', value: 'a@x.com' }, { name: 'Subject', value: 'Hi' }, { name: 'X-Spam', value: 'no' }, { value: 'orphan-no-name' }], body: { data: 'AAAA' } } },
+        { id: 'm2', threadId: 't1', internalDate: '2', labelIds: ['INBOX'], snippet: 'second', payload: { headers: [{ name: 'From', value: 'b@x.com' }] } },
+        { id: 'm3', threadId: 't1', internalDate: '3', labelIds: ['SENT'], snippet: 'third' },
+      ],
+    },
+  });
+
+  it('does not transform the output when no paging params are given', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(THREAD));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1' });
+    expect(result.content[0].text).toBe(THREAD);
+  });
+
+  it('latestN returns only the last N messages', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(THREAD));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', latestN: 2 });
+    // latestN is wrapper-side; no CLI flag is added
+    expect(vi.mocked(lib.runOrDiagnose).mock.calls[0]![0]).toEqual(['gmail', 'thread', 'get', 't1']);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.thread.messages.map((m: { id: string }) => m.id)).toEqual(['m2', 'm3']);
+  });
+
+  it('snippetsOnly returns per-message headers and snippet without bodies', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(THREAD));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', snippetsOnly: true });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.thread.messages).toHaveLength(3);
+    const m1 = parsed.thread.messages[0];
+    expect(m1.snippet).toBe('first');
+    expect(m1.headers).toEqual({ From: 'a@x.com', Subject: 'Hi' }); // X-Spam dropped
+    expect(m1.payload).toBeUndefined();
+    // a message with no payload yields empty headers without throwing
+    expect(parsed.thread.messages[2].headers).toEqual({});
+  });
+
+  it('combines latestN and snippetsOnly', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText(THREAD));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', latestN: 1, snippetsOnly: true });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.thread.messages).toHaveLength(1);
+    expect(parsed.thread.messages[0].id).toBe('m3');
+  });
+
+  it('returns the raw result when the payload is not JSON', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('not json'));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', latestN: 2 });
+    expect(result.content[0].text).toBe('not json');
+  });
+
+  it('returns the raw result when there is no messages array', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('{"thread":{}}'));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', snippetsOnly: true });
+    expect(result.content[0].text).toBe('{"thread":{}}');
+  });
+
+  it('returns the raw result when there is no thread object', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('{}'));
+    const result = await handlers.get('gog_gmail_thread_get')!({ threadId: 't1', latestN: 1 });
+    expect(result.content[0].text).toBe('{}');
+  });
 });
 
 describe('gog_gmail_thread_modify', () => {
@@ -430,6 +496,53 @@ describe('gog_gmail_drafts_create', () => {
       { account: undefined },
     );
   });
+
+  it('skips recipient flags when omitRecipients is true, even if to/cc/bcc are supplied', async () => {
+    await handlers.get('gog_gmail_drafts_create')!({
+      to: 'a@b.com', cc: 'cc@x.com', bcc: 'bcc@x.com',
+      subject: 'Hi', body: 'Hello', omitRecipients: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'],
+      { account: undefined },
+    );
+  });
+
+  it('returnFull re-fetches and returns the full stored draft', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(toText('{"draftId":"d9","message":{"id":"m9"}}'))
+      .mockResolvedValueOnce(toText('{"id":"d9","message":{"subject":"Hi","body":"Hello"}}'));
+    const result = await handlers.get('gog_gmail_drafts_create')!({
+      subject: 'Hi', body: 'Hello', returnFull: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(1,
+      ['gmail', 'drafts', 'create', '--subject=Hi', '--body=Hello'], { account: undefined });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
+      ['gmail', 'drafts', 'get', 'd9'], { account: undefined });
+    expect(result.content[0].text).toContain('"subject":"Hi"');
+  });
+
+  it('returnFull does not push --return-full to the CLI', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(toText('{"draftId":"d9"}'))
+      .mockResolvedValueOnce(toText('{}'));
+    await handlers.get('gog_gmail_drafts_create')!({ subject: 'Hi', body: 'Hello', returnFull: true });
+    expect(vi.mocked(lib.runOrDiagnose).mock.calls[0]![0]).not.toContain('--return-full');
+  });
+
+  it('returnFull returns the write result when output is not parseable JSON', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('not json'));
+    const result = await handlers.get('gog_gmail_drafts_create')!({ subject: 'Hi', body: 'Hello', returnFull: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toBe('not json');
+  });
+
+  it('returnFull returns the write result when no draftId is present', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('{"message":{"id":"m9"}}'));
+    const result = await handlers.get('gog_gmail_drafts_create')!({ subject: 'Hi', body: 'Hello', returnFull: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toBe('{"message":{"id":"m9"}}');
+  });
 });
 
 describe('gog_gmail_drafts_update', () => {
@@ -457,6 +570,38 @@ describe('gog_gmail_drafts_update', () => {
       { account: undefined },
     );
   });
+
+  it('skips recipient flags when omitRecipients is true', async () => {
+    await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1', to: 'a@b.com', subject: 'S', body: 'B', omitRecipients: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'update', 'd1', '--subject=S', '--body=B'],
+      { account: undefined },
+    );
+  });
+
+  it('returnFull re-fetches the draft by its known id', async () => {
+    vi.mocked(lib.runOrDiagnose)
+      .mockResolvedValueOnce(toText('{"draftId":"d1"}'))
+      .mockResolvedValueOnce(toText('{"id":"d1","message":{"subject":"S"}}'));
+    const result = await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1', subject: 'S', body: 'B', returnFull: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenNthCalledWith(2,
+      ['gmail', 'drafts', 'get', 'd1'], { account: undefined });
+    expect(result.content[0].text).toContain('"subject":"S"');
+  });
+
+  it('returnFull surfaces a failed update instead of re-fetching a stale draft', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValueOnce(toText('Error: update failed'));
+    const result = await handlers.get('gog_gmail_drafts_update')!({
+      draftId: 'd1', subject: 'S', body: 'B', returnFull: true,
+    });
+    // write failed (non-JSON) → no re-fetch; the error is surfaced
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toBe('Error: update failed');
+  });
 });
 
 describe('gog_gmail_drafts_delete', () => {
@@ -467,6 +612,22 @@ describe('gog_gmail_drafts_delete', () => {
       { account: undefined },
     );
   });
+
+  it('appends --force when force is true', async () => {
+    await handlers.get('gog_gmail_drafts_delete')!({ draftId: 'd1', force: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'delete', 'd1', '--force'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --force when force is false', async () => {
+    await handlers.get('gog_gmail_drafts_delete')!({ draftId: 'd1', force: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'drafts', 'delete', 'd1'],
+      { account: undefined },
+    );
+  });
 });
 
 describe('gog_gmail_drafts_send', () => {
@@ -587,3 +748,291 @@ describe('gog_gmail_autoreply', () => {
     );
   });
 });
+
+describe('gog_gmail_messages_search', () => {
+  it('calls runOrDiagnose with just the query', async () => {
+    await handlers.get('gog_gmail_messages_search')!({ query: 'from:alice' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'from:alice'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_messages_search')!({
+      query: 'is:unread',
+      max: 10,
+      page: 'tok',
+      all: true,
+      includeBody: true,
+      full: true,
+      bodyFormat: 'html',
+      account: 'me@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'is:unread', '--max=10', '--page=tok', '--all', '--include-body', '--full', '--body-format=html'],
+      { account: 'me@x.com' },
+    );
+  });
+
+  it('omits flags when false/absent', async () => {
+    await handlers.get('gog_gmail_messages_search')!({ query: 'x', all: false, includeBody: false, full: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'x'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_style', () => {
+  it('calls runOrDiagnose with just the label', async () => {
+    await handlers.get('gog_gmail_labels_style')!({ labelIdOrName: 'Work' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'style', 'Work'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all style flags when provided', async () => {
+    await handlers.get('gog_gmail_labels_style')!({
+      labelIdOrName: 'Work',
+      backgroundColor: '#000000',
+      textColor: '#ffffff',
+      labelListVisibility: 'labelHide',
+      messageListVisibility: 'hide',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'style', 'Work', '--background-color=#000000', '--text-color=#ffffff', '--label-list-visibility=labelHide', '--message-list-visibility=hide'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_vacation_get', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_vacation_get')!({ account: 'me@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'get'],
+      { account: 'me@x.com' },
+    );
+  });
+});
+
+describe('gog_gmail_vacation_update', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update'],
+      { account: undefined },
+    );
+  });
+
+  it('enables with subject/body/start/end and scoping', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({
+      enable: true,
+      subject: 'Away',
+      body: '<p>OOO</p>',
+      start: '2024-12-20T00:00:00Z',
+      end: '2024-12-31T23:59:59Z',
+      contactsOnly: true,
+      domainOnly: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update', '--enable', '--subject=Away', '--body=<p>OOO</p>', '--start=2024-12-20T00:00:00Z', '--end=2024-12-31T23:59:59Z', '--contacts-only', '--domain-only'],
+      { account: undefined },
+    );
+  });
+
+  it('disables the responder', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({ disable: true, enable: false, contactsOnly: false, domainOnly: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update', '--disable'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_list', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_filters_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'list'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_get', () => {
+  it('calls runOrDiagnose with the filter ID', async () => {
+    await handlers.get('gog_gmail_filters_get')!({ filterId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'get', 'f1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_create', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_filters_create')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all criteria and actions when provided', async () => {
+    await handlers.get('gog_gmail_filters_create')!({
+      from: 'alice@x.com',
+      to: 'me@x.com',
+      subject: 'Report',
+      query: 'has:attachment',
+      hasAttachment: true,
+      addLabel: 'Reports',
+      removeLabel: 'INBOX',
+      archive: true,
+      markRead: true,
+      star: true,
+      important: true,
+      trash: true,
+      neverSpam: true,
+      forward: 'fwd@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create', '--from=alice@x.com', '--to=me@x.com', '--subject=Report', '--query=has:attachment', '--has-attachment', '--add-label=Reports', '--remove-label=INBOX', '--archive', '--mark-read', '--star', '--important', '--trash', '--never-spam', '--forward=fwd@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_filters_create')!({
+      from: 'a@x.com',
+      hasAttachment: false,
+      archive: false,
+      markRead: false,
+      star: false,
+      important: false,
+      trash: false,
+      neverSpam: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create', '--from=a@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_delete', () => {
+  it('calls runOrDiagnose with the filter ID', async () => {
+    await handlers.get('gog_gmail_filters_delete')!({ filterId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'delete', 'f1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_list', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_sendas_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'list'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_get', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_get')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'get', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_create', () => {
+  it('calls runOrDiagnose with just the email', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({
+      email: 'alias@x.com',
+      displayName: 'Alias',
+      replyTo: 'reply@x.com',
+      signature: '<p>sig</p>',
+      treatAsAlias: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com', '--display-name=Alias', '--reply-to=reply@x.com', '--signature=<p>sig</p>', '--treat-as-alias'],
+      { account: undefined },
+    );
+  });
+
+  it('omits treatAsAlias when false', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({ email: 'alias@x.com', treatAsAlias: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_update', () => {
+  it('calls runOrDiagnose with just the email', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({
+      email: 'alias@x.com',
+      displayName: 'Alias',
+      replyTo: 'reply@x.com',
+      signature: '<p>sig</p>',
+      treatAsAlias: true,
+      makeDefault: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com', '--display-name=Alias', '--reply-to=reply@x.com', '--signature=<p>sig</p>', '--treat-as-alias', '--make-default'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({ email: 'alias@x.com', treatAsAlias: false, makeDefault: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_delete', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_delete')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'delete', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_verify', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_verify')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'verify', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});