gogcli-mcp 4.3.0 → 4.4.0

package/tests/tools/gmail-confirm-token.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+import { metadataThreadId, registerGmailTools } from '../../src/tools/gmail.js';
+import * as runner from '../../src/runner.js';
+import { pos } from '../../src/argv.js';
+import { resetConfirmTokenState } from '../../src/send-confirm-token.js';
+
+vi.mock('../../src/runner.js');
+
+// ============================================================================
+// The two-phase confirmToken fallback on the base package's send tools,
+// driven through the real MCP RPC path. A harness registered WITHOUT an
+// elicitation handler is a client that declares no elicitation — claude.ai's
+// measured shape.
+// ============================================================================
+
+const ORIGINAL_ENV = { ...process.env };
+let fileRoot: string;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  process.env = { ...ORIGINAL_ENV };
+  delete process.env.GOG_SEND_CONFIRM_FALLBACK;
+  delete process.env.GOG_CONFIRM_TTL_SECONDS;
+  delete process.env.GOG_CONFIRM_SECRET;
+  process.env.GOG_ACCOUNT = 'me@example.com';
+  fileRoot = mkdtempSync(join(tmpdir(), 'gct-roots-'));
+  process.env.GOG_FILE_ROOTS = fileRoot;
+  resetConfirmTokenState();
+  vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+});
+
+afterEach(() => {
+  process.env = ORIGINAL_ENV;
+  vi.restoreAllMocks();
+  vi.useRealTimers();
+});
+
+const noElicitation = () => createTestHarness(registerGmailTools);
+const withElicitation = () => createTestHarness(registerGmailTools, {
+  elicitation: async () => ({ action: 'accept', content: { confirmed: true } }),
+});
+const json = (r: { content: Array<{ text?: string }> }) => JSON.parse(r.content[0]!.text as string);
+const SENT = '{"id":"sent1"}';
+
+const SEND_ARGS = {
+  to: 'alice@example.com',
+  cc: 'carol@example.com',
+  bcc: 'secret-bcc@example.com',
+  subject: 'Quarterly numbers',
+  body: 'Hi Alice,\n\nNumbers attached.\n\n— me',
+};
+
+const sendCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args[0] === 'gmail' && args[1] === 'send');
+
+describe('gog_gmail_send — token fallback', () => {
+  it('elicitation supported: unchanged — prompts and sends, confirmToken or not', async () => {
+    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    vi.mocked(runner.run).mockResolvedValue(SENT);
+    const harness = await withElicitation();
+    const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: 'gct1.not.real' });
+    expect(result.content[0]!.text).toBe(SENT);
+    expect(sendCalls()).toHaveLength(1);
+  });
+
+  it('unsupported + env unset: refuses, with the new hint', async () => {
+    const harness = await noElicitation();
+    const body = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
+    expect(body).toMatchObject({ confirmed: false, dispatched: false, reason: 'confirmation-unsupported' });
+    expect(body.note).toContain('set GOG_SEND_CONFIRM_FALLBACK=token to enable two-step confirmation');
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  describe('unsupported + GOG_SEND_CONFIRM_FALLBACK=token', () => {
+    beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+
+    it('phase 1 previews everything (Bcc included, full body) and sends nothing', async () => {
+      const long = `${'x'.repeat(5000)}END`;
+      const harness = await noElicitation();
+      const body = json(await harness.callTool('gog_gmail_send', {
+        ...SEND_ARGS,
+        body: long,
+        threadId: 't1',
+        replyToMessageId: 'm0',
+        attachInline: [{ filename: 'q3.csv', contentBase64: Buffer.from('a,b\n1,2\n').toString('base64') }],
+      }));
+      expect(body.status).toBe('confirmation-required');
+      expect(body.dispatched).toBe(false);
+      expect(body.preview).toEqual({
+        from: 'me@example.com',
+        to: 'alice@example.com',
+        cc: 'carol@example.com',
+        bcc: 'secret-bcc@example.com',
+        subject: 'Quarterly numbers',
+        body: long,
+        attachments: [{ name: 'q3.csv', size: 8 }],
+        threadId: 't1',
+        inReplyTo: 'm0',
+        quotesOriginal: false,
+      });
+      expect(body.confirmToken).toMatch(/^gct1\./);
+      expect(body.instruction).toMatch(/verbatim/);
+      expect(runner.run).not.toHaveBeenCalled();
+    });
+
+    it('phase 2 with a valid token sends, exactly once', async () => {
+      vi.mocked(runner.run).mockResolvedValue(SENT);
+      const harness = await noElicitation();
+      const { confirmToken } = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
+      const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken });
+      expect(result.content[0]!.text).toBe(SENT);
+      expect(sendCalls()).toHaveLength(1);
+      expect(sendCalls()[0]![0]).toContain('--bcc=secret-bcc@example.com');
+
+      const again = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken });
+      expect(json(again)).toMatchObject({ error: 'TOKEN_REUSED', dispatched: false });
+      expect(sendCalls()).toHaveLength(1);
+    });
+
+    it('phase 2 with ANY changed argument is DRAFT_CHANGED and sends nothing', async () => {
+      const harness = await noElicitation();
+      const { confirmToken } = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
+      const body = json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, bcc: 'someone-else@example.com', confirmToken }));
+      expect(body).toMatchObject({ error: 'DRAFT_CHANGED', reason: 'payload-changed', dispatched: false });
+      expect(body.preview.bcc).toBe('someone-else@example.com');
+      expect(sendCalls()).toHaveLength(0);
+    });
+
+    it('binds a server-side attachment by content: a same-size swap is DRAFT_CHANGED', async () => {
+      const path = join(fileRoot, 'report.txt');
+      writeFileSync(path, 'v1');
+      const harness = await noElicitation();
+      const first = json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, attach: [path] }));
+      expect(first.preview.attachments).toEqual([{ name: path, size: 2 }]);
+      writeFileSync(path, 'v2');
+      const body = json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, attach: [path], confirmToken: first.confirmToken }));
+      expect(body.error).toBe('DRAFT_CHANGED');
+      expect(sendCalls()).toHaveLength(0);
+    });
+
+    it('rejects an expired token', async () => {
+      vi.useFakeTimers({ toFake: ['Date'] });
+      vi.setSystemTime(new Date('2026-09-24T10:00:00Z'));
+      const harness = await noElicitation();
+      const { confirmToken } = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
+      vi.setSystemTime(new Date('2026-09-24T10:10:01Z'));
+      expect(json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken }))).toMatchObject({ error: 'TOKEN_EXPIRED' });
+      expect(sendCalls()).toHaveLength(0);
+    });
+
+    it('rejects a tampered token', async () => {
+      const harness = await noElicitation();
+      const { confirmToken } = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
+      const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: `${confirmToken}x` });
+      expect(result.isError).toBe(true);
+      expect(json(result)).toMatchObject({ error: 'TOKEN_INVALID' });
+      expect(sendCalls()).toHaveLength(0);
+    });
+
+    it('rejects a token issued to a different account', async () => {
+      const harness = await noElicitation();
+      const { confirmToken } = json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, account: 'other@example.com' }));
+      expect(json(await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken }))).toMatchObject({ error: 'TOKEN_INVALID' });
+    });
+  });
+});
+
+describe.each([
+  ['gog_gmail_reply', 'reply'],
+  ['gog_gmail_reply_all', 'reply-all'],
+] as const)('%s — token fallback', (tool, subcommand) => {
+  const metadata = (messageIdHeader = '<orig@mail.example.com>') => JSON.stringify({
+    message: { id: 'm1', threadId: 't1' },
+    headers: {
+      from: 'Alice <alice@example.com>',
+      to: 'me@example.com',
+      cc: 'Carol <carol@example.com>',
+      subject: 'Contract terms',
+      message_id: messageIdHeader,
+      references: '<root@mail.example.com>',
+    },
+  });
+  const replyCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args[1] === subcommand);
+
+  beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+
+  it('phase 1 previews the resolved recipients, Bcc, full body and In-Reply-To; nothing sent', async () => {
+    vi.mocked(runner.run).mockResolvedValue(metadata());
+    const harness = await noElicitation();
+    const body = json(await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.', bcc: ['auditor@example.com'] }));
+    expect(body.status).toBe('confirmation-required');
+    expect(body.preview).toMatchObject({
+      from: 'me@example.com',
+      to: subcommand === 'reply' ? ['alice@example.com'] : ['alice@example.com', 'me@example.com'],
+      cc: subcommand === 'reply' ? [] : ['carol@example.com'],
+      bcc: ['auditor@example.com'],
+      subject: 'Re: Contract terms',
+      body: 'Agreed.',
+      quotesOriginal: true,
+      threadId: 't1',
+      inReplyTo: '<orig@mail.example.com>',
+      replyingToMessageId: 'm1',
+    });
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(replyCalls()).toHaveLength(0);
+  });
+
+  it('phase 2 re-reads the original and sends with a valid token', async () => {
+    vi.mocked(runner.run).mockResolvedValue(metadata());
+    const harness = await noElicitation();
+    const { confirmToken } = json(await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.' }));
+    vi.mocked(runner.run).mockResolvedValueOnce(metadata()).mockResolvedValueOnce(SENT);
+    const result = await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.', confirmToken });
+    expect(result.content[0]!.text).toBe(SENT);
+    expect(runner.run).toHaveBeenLastCalledWith(
+      ['gmail', subcommand, pos('m1'), '--body=Agreed.', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+  });
+
+  it('refuses when the original re-reads differently (DRAFT_CHANGED)', async () => {
+    vi.mocked(runner.run).mockResolvedValue(metadata());
+    const harness = await noElicitation();
+    const { confirmToken } = json(await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.' }));
+    vi.mocked(runner.run).mockResolvedValue(metadata('<different@mail.example.com>'));
+    const body = json(await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.', confirmToken }));
+    expect(body).toMatchObject({ error: 'DRAFT_CHANGED', dispatched: false });
+    expect(replyCalls()).toHaveLength(0);
+  });
+
+  it('rejects a token issued for a different message', async () => {
+    vi.mocked(runner.run).mockResolvedValue(metadata());
+    const harness = await noElicitation();
+    const { confirmToken } = json(await harness.callTool(tool, { messageId: 'm-other', body: 'Agreed.' }));
+    expect(json(await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.', confirmToken }))).toMatchObject({ error: 'TOKEN_INVALID' });
+    expect(replyCalls()).toHaveLength(0);
+  });
+
+  it('shows the alias choice, HTML body, file-backed body and signature when set', async () => {
+    vi.mocked(runner.run).mockResolvedValue('not json');
+    const htmlPath = join(fileRoot, 'body.html');
+    writeFileSync(htmlPath, '<p>hi</p>');
+    const harness = await noElicitation();
+    const a = json(await harness.callTool(tool, { messageId: 'm1', bodyHtmlFile: htmlPath, autoFromAddressedAlias: true, signature: true, noQuote: true }));
+    expect(a.preview).toMatchObject({
+      from: 'the send-as alias the original was addressed to',
+      bodyHtmlFile: htmlPath,
+      signature: 'the Gmail signature of the sending address',
+      quotesOriginal: false,
+    });
+    expect(a.preview.threadId).toBeUndefined();
+    const b = json(await harness.callTool(tool, { messageId: 'm1', bodyHtml: '<b>x</b>', from: 'alias@example.com', signatureFrom: 'alias@example.com', remove: ['alice@example.com'] }));
+    expect(b.preview).toMatchObject({ from: 'alias@example.com', bodyHtml: '<b>x</b>', signature: 'alias@example.com' });
+  });
+
+  it('elicitation supported: unchanged', async () => {
+    vi.mocked(runner.run).mockResolvedValueOnce(metadata()).mockResolvedValueOnce(metadata()).mockResolvedValueOnce(SENT);
+    const harness = await withElicitation();
+    const result = await harness.callTool(tool, { messageId: 'm1', body: 'Agreed.' });
+    expect(result.content[0]!.text).toBe(SENT);
+  });
+});
+
+describe('metadataThreadId', () => {
+  it('reads message.threadId and ignores anything else', () => {
+    expect(metadataThreadId('{"message":{"threadId":"t1"}}')).toBe('t1');
+    expect(metadataThreadId('{"message":{"threadId":5}}')).toBeUndefined();
+    expect(metadataThreadId('null')).toBeUndefined();
+    expect(metadataThreadId('not json')).toBeUndefined();
+  });
+});

package/tests/tools/run-vets.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+import * as runner from '../../src/runner.js';
+import { registerChatTools, vetChatRun } from '../../src/tools/chat.js';
+import { registerDriveTools, vetDriveRun } from '../../src/tools/drive.js';
+import { registerClassroomTools, vetClassroomRun } from '../../src/tools/classroom.js';
+import { registerCalendarTools, vetCalendarRun } from '../../src/tools/calendar.js';
+import { refusedApiCall } from '../../src/tools/api.js';
+
+vi.mock('../../src/runner.js');
+
+// ============================================================================
+// The escape hatches must not be a way around the dispatch rail (#400): every
+// action a dedicated tool asks the user about is refused by gog_<service>_run
+// and gog_api_call, under every alias gog accepts for it.
+// ============================================================================
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('vetChatRun', () => {
+  it.each([
+    ['messages', ['send', 'spaces/A', '--text=hi']],
+    ['messages', ['create', 'spaces/A']],
+    ['messages', ['post', 'spaces/A']],
+    ['dm', ['send', 'a@example.com']],
+    ['DM', ['--color', 'never', 'POST', 'a@example.com']],
+  ])('refuses %s %j', (sub, args) => {
+    expect(vetChatRun(sub, args)).toMatch(/gog_chat_(messages|dm)_send.*asks the user/);
+  });
+
+  it.each([
+    ['messages', ['list', 'spaces/A']],
+    ['messages', ['react', 'spaces/A/messages/B', '--emoji=👍']],
+    ['dm', ['space', 'a@example.com']],
+    ['spaces', ['send']],
+    ['messages', ['search', '--query=send']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetChatRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetDriveRun', () => {
+  it.each(['share', 'SHARE'])('refuses %s', (sub) => {
+    expect(vetDriveRun(sub, ['f1', '--to=anyone'])).toMatch(/gog_drive_share.*asks the user/);
+  });
+
+  it.each(['permissions', 'unshare', 'copy'])('allows %s', (sub) => {
+    expect(vetDriveRun(sub, ['f1'])).toBeUndefined();
+  });
+});
+
+describe('vetClassroomRun', () => {
+  it.each([
+    ['announcements', ['create', 'c1', '--text=x']],
+    ['announcement', ['add', 'c1']],
+    ['ann', ['new', 'c1']],
+    ['invitations', ['create', 'c1', 'u1']],
+    ['invitation', ['add', 'c1', 'u1']],
+    ['invites', ['NEW', 'c1', 'u1']],
+  ])('refuses %s %j', (sub, args) => {
+    expect(vetClassroomRun(sub, args)).toMatch(/gog_classroom_(announcements|invitations)_create.*asks the user/);
+  });
+
+  it.each([
+    ['announcements', ['list', 'c1']],
+    ['invitations', ['accept', 'i1']],
+    ['guardians', ['create', 'c1']],
+    ['courses', ['create']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetClassroomRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetCalendarRun', () => {
+  it.each(['create', 'add', 'new', 'update', 'edit', 'set', 'respond', 'rsvp', 'reply', 'Create'])('refuses %s', (sub) => {
+    expect(vetCalendarRun(sub, ['primary'])).toMatch(/gog_calendar_(create|update|respond).*asks the user/);
+  });
+
+  it.each(['events', 'freebusy', 'calendars', 'create-calendar', 'focus-time'])('allows %s', (sub) => {
+    expect(vetCalendarRun(sub, [])).toBeUndefined();
+  });
+});
+
+describe('the vets are wired into the run tools', () => {
+  it.each([
+    [registerChatTools, 'gog_chat_run', { subcommand: 'messages', args: ['send', 'spaces/A', '--text=hi'] }],
+    [registerDriveTools, 'gog_drive_run', { subcommand: 'share', args: ['f1', '--to=anyone'] }],
+    [registerClassroomTools, 'gog_classroom_run', { subcommand: 'ann', args: ['create', 'c1', '--text=x'] }],
+    [registerCalendarTools, 'gog_calendar_run', { subcommand: 'rsvp', args: ['primary', 'e1', '--status=accepted'] }],
+  ] as const)('%#: %s refuses without spawning gog', async (register, tool, args) => {
+    const harness = await createTestHarness(register);
+    const result = await harness.callTool(tool, args);
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toMatch(/asks the user to confirm/);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('refusedApiCall — the dispatch rail\'s other escape hatch', () => {
+  it.each([
+    ['chat', 'spaces.messages.create', 'gog_chat_messages_send'],
+    ['chat', 'chat.spaces.messages.create', 'gog_chat_messages_send'],
+    ['drive', 'permissions.create', 'gog_drive_share'],
+    ['drive', 'permissions.update', 'gog_drive_share'],
+    ['classroom', 'courses.announcements.create', 'gog_classroom_announcements_create'],
+    ['classroom', 'invitations.create', 'gog_classroom_invitations_create'],
+    ['calendar', 'events.insert', 'gog_calendar_create'],
+    ['Calendar', ' events.patch ', 'gog_calendar_update'],
+    ['calendar', 'events.update', 'gog_calendar_update'],
+    ['calendar', 'events.import', 'gog_calendar_create'],
+    ['calendar', 'events.quickAdd', 'gog_calendar_create'],
+  ])('refuses %s %s', (api, method, tool) => {
+    expect(refusedApiCall(api, method)).toContain(tool);
+  });
+
+  it.each([
+    ['chat', 'spaces.messages.list'],
+    ['drive', 'permissions.list'],
+    ['drive', 'permissions.delete'],
+    ['classroom', 'courses.announcements.list'],
+    ['calendar', 'events.list'],
+    ['calendar', 'events.delete'],
+    ['sheets', 'spreadsheets.values.update'],
+  ])('allows %s %s', (api, method) => {
+    expect(refusedApiCall(api, method)).toBeUndefined();
+  });
+
+  it('still refuses Gmail sends', () => {
+    expect(refusedApiCall('gmail', 'users.messages.send')).toMatch(/gog_gmail_send/);
+  });
+});