gogcli-mcp 4.4.0 → 4.5.0

package/tests/send-confirm-token.test.ts

@@ -1,200 +1,20 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  CONFIRM_TOKEN_TTL_DEFAULT_SECONDS,
-  confirmTokenTtlSeconds,
-  hashSendPayload,
-  issueConfirmToken,
-  resetConfirmTokenState,
-  sendConfirmFallbackEnabled,
-  verifyConfirmToken,
-  type ConfirmBinding,
-} from '../src/send-confirm-token.js';
-
-const ORIGINAL_ENV = { ...process.env };
-
-const BINDING: ConfirmBinding = {
-  tool: 'gog_gmail_drafts_send',
-  account: 'me@example.com',
-  target: 'r123',
-  revision: 'msg-1',
-  payloadHash: hashSendPayload({ to: 'a@example.com', body: 'hello' }),
-};
-
-const NOW = 1_800_000_000_000;
-
-beforeEach(() => {
-  process.env = { ...ORIGINAL_ENV };
-  delete process.env.GOG_SEND_CONFIRM_FALLBACK;
-  delete process.env.GOG_CONFIRM_SECRET;
-  delete process.env.GOG_CONFIRM_TTL_SECONDS;
-  resetConfirmTokenState();
-});
-
-afterEach(() => {
-  process.env = ORIGINAL_ENV;
-  resetConfirmTokenState();
-});
-
-describe('hashSendPayload', () => {
-  it('is independent of key order, so a re-read payload hashes the same', () => {
-    expect(hashSendPayload({ a: 1, b: { c: 2, d: [1, 2] } }))
-      .toBe(hashSendPayload({ b: { d: [1, 2], c: 2 }, a: 1 }));
-  });
-
-  it('changes when any value changes, including array order', () => {
-    const base = hashSendPayload({ to: ['a', 'b'], body: 'x' });
-    expect(hashSendPayload({ to: ['b', 'a'], body: 'x' })).not.toBe(base);
-    expect(hashSendPayload({ to: ['a', 'b'], body: 'x ' })).not.toBe(base);
-  });
-
-  it('treats an undefined field as absent', () => {
-    expect(hashSendPayload({ a: 1, b: undefined })).toBe(hashSendPayload({ a: 1 }));
-  });
-
-  it('distinguishes null from absent', () => {
-    expect(hashSendPayload({ a: null })).not.toBe(hashSendPayload({}));
-  });
-});
-
-describe('sendConfirmFallbackEnabled', () => {
-  it('is off unless GOG_SEND_CONFIRM_FALLBACK is exactly "token" (case-insensitive)', () => {
-    expect(sendConfirmFallbackEnabled()).toBe(false);
-    process.env.GOG_SEND_CONFIRM_FALLBACK = '1';
-    expect(sendConfirmFallbackEnabled()).toBe(false);
-    process.env.GOG_SEND_CONFIRM_FALLBACK = ' Token ';
-    expect(sendConfirmFallbackEnabled()).toBe(true);
-  });
-
-  it('treats an unresolved .mcpb placeholder as unset', () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = '${user_config.send_confirm_fallback}';
-    expect(sendConfirmFallbackEnabled()).toBe(false);
-  });
-});
-
-describe('confirmTokenTtlSeconds', () => {
-  it('defaults to ten minutes', () => {
-    expect(CONFIRM_TOKEN_TTL_DEFAULT_SECONDS).toBe(600);
-    expect(confirmTokenTtlSeconds()).toBe(600);
-  });
-
-  it('honours a positive integer GOG_CONFIRM_TTL_SECONDS', () => {
-    process.env.GOG_CONFIRM_TTL_SECONDS = '30';
-    expect(confirmTokenTtlSeconds()).toBe(30);
-  });
-
-  it.each(['0', '-5', 'abc', '1.5', ''])('falls back to the default for %j', (value) => {
-    process.env.GOG_CONFIRM_TTL_SECONDS = value;
-    expect(confirmTokenTtlSeconds()).toBe(600);
-  });
-});
-
-describe('issueConfirmToken / verifyConfirmToken', () => {
-  it('accepts a fresh token for the exact binding it was issued for', () => {
-    const { token, expiresAt } = issueConfirmToken(BINDING, NOW);
-    expect(expiresAt).toBe(new Date(NOW + 600_000).toISOString());
-    expect(verifyConfirmToken(token, BINDING, NOW + 1_000)).toEqual({ ok: true });
-  });
-
-  it('is single-use: the second presentation is TOKEN_REUSED', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(token, BINDING, NOW)).toEqual({ ok: true });
-    expect(verifyConfirmToken(token, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_REUSED' });
-  });
-
-  it('expires after the TTL', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(token, BINDING, NOW + 600_001)).toMatchObject({ ok: false, error: 'TOKEN_EXPIRED' });
-  });
-
-  it('uses GOG_CONFIRM_TTL_SECONDS at issue time', () => {
-    process.env.GOG_CONFIRM_TTL_SECONDS = '5';
-    const { token } = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(token, BINDING, NOW + 5_001)).toMatchObject({ ok: false, error: 'TOKEN_EXPIRED' });
-  });
-
-  it('does not consume a token that failed verification', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    const changed = { ...BINDING, payloadHash: hashSendPayload({ to: 'b@example.com' }) };
-    expect(verifyConfirmToken(token, changed, NOW)).toMatchObject({ ok: false, error: 'DRAFT_CHANGED' });
-    expect(verifyConfirmToken(token, BINDING, NOW)).toEqual({ ok: true });
-  });
-
-  it('reports DRAFT_CHANGED with reason payload-changed when the payload hash differs', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    const changed = { ...BINDING, payloadHash: hashSendPayload({ to: 'a@example.com', body: 'HELLO' }) };
-    expect(verifyConfirmToken(token, changed, NOW)).toEqual({ ok: false, error: 'DRAFT_CHANGED', reason: 'payload-changed' });
-  });
-
-  it('reports DRAFT_CHANGED with reason message-id-rotated when the revision rotated', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(token, { ...BINDING, revision: 'msg-2' }, NOW))
-      .toEqual({ ok: false, error: 'DRAFT_CHANGED', reason: 'message-id-rotated' });
-  });
-
-  it.each([
-    ['tool', { tool: 'gog_gmail_send' }],
-    ['account', { account: 'other@example.com' }],
-    ['draft/message', { target: 'r999' }],
-  ] as const)('never accepts a token issued for a different %s', (_label, override) => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(token, { ...BINDING, ...override }, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it('rejects a tampered claim as TOKEN_INVALID', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    const [prefix, claims, sig] = token.split('.');
-    const decoded = JSON.parse(Buffer.from(claims!, 'base64url').toString('utf8'));
-    decoded.exp += 3_600_000;
-    const forged = `${prefix}.${Buffer.from(JSON.stringify(decoded)).toString('base64url')}.${sig}`;
-    expect(verifyConfirmToken(forged, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it('rejects a tampered signature as TOKEN_INVALID', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    const flipped = token.slice(0, -2) + (token.endsWith('AA') ? 'BB' : 'AA');
-    expect(verifyConfirmToken(flipped, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it.each(['', 'garbage', 'gct1.a.b', 'x.y.z', 'gct1..', 'gct1.a.b.c'])('rejects malformed token %j as TOKEN_INVALID', (token) => {
-    expect(verifyConfirmToken(token, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it('rejects a correctly signed token whose claims are not JSON', async () => {
-    const { createHmac } = await import('node:crypto');
-    process.env.GOG_CONFIRM_SECRET = 'a-shared-secret';
+import { describe, it, expect } from 'vitest';
+import { confirmKeyFromEnv, issueConfirmToken, verifyConfirmToken } from '@chrischall/mcp-utils';
+import { confirmSpentStore, resetConfirmTokenState } from '../src/send-confirm-token.js';
+
+// The token mechanism and the MCP_CONFIRM_* env layer live in
+// @chrischall/mcp-utils and are tested there. What stays here is this server's
+// spent-token store and the seam its tests reset it with.
+describe('confirmSpentStore', () => {
+  it('is one store for the process, emptied by resetConfirmTokenState', () => {
+    const binding = { tool: 'gog_gmail_send', account: 'me@example.com', target: '', payloadHash: 'h' };
+    const key = confirmKeyFromEnv({});
+    const { token } = issueConfirmToken(key, binding);
+    expect(verifyConfirmToken(key, token, binding, { spent: confirmSpentStore() })).toEqual({ ok: true });
+    expect(confirmSpentStore()).toBe(confirmSpentStore());
+    expect(confirmSpentStore().size).toBe(1);
+    expect(verifyConfirmToken(key, token, binding, { spent: confirmSpentStore() })).toEqual({ ok: false, error: 'TOKEN_REUSED' });
     resetConfirmTokenState();
-    const claims = Buffer.from('not json').toString('base64url');
-    const sig = createHmac('sha256', 'a-shared-secret').update(`gct1.${claims}`).digest('base64url');
-    expect(verifyConfirmToken(`gct1.${claims}.${sig}`, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it('rejects a token signed by a previous process (per-process secret)', () => {
-    const { token } = issueConfirmToken(BINDING, NOW);
-    resetConfirmTokenState();
-    expect(verifyConfirmToken(token, BINDING, NOW)).toMatchObject({ ok: false, error: 'TOKEN_INVALID' });
-  });
-
-  it('with GOG_CONFIRM_SECRET set, a token survives a restart', () => {
-    process.env.GOG_CONFIRM_SECRET = 'a-shared-secret';
-    resetConfirmTokenState();
-    const { token } = issueConfirmToken(BINDING, NOW);
-    resetConfirmTokenState();
-    expect(verifyConfirmToken(token, BINDING, NOW)).toEqual({ ok: true });
-  });
-
-  it('binds a revision-less subject too', () => {
-    const noRevision = { ...BINDING, revision: undefined };
-    const { token } = issueConfirmToken(noRevision, NOW);
-    expect(verifyConfirmToken(token, noRevision, NOW)).toEqual({ ok: true });
-  });
-
-  it('forgets used tokens once they would have expired anyway', () => {
-    const first = issueConfirmToken(BINDING, NOW);
-    expect(verifyConfirmToken(first.token, BINDING, NOW)).toEqual({ ok: true });
-    // A later verification prunes the spent entry; the old token is then
-    // rejected as expired rather than remembered forever.
-    const second = issueConfirmToken(BINDING, NOW + 700_000);
-    expect(verifyConfirmToken(second.token, BINDING, NOW + 700_000)).toEqual({ ok: true });
-    expect(verifyConfirmToken(first.token, BINDING, NOW + 700_000)).toMatchObject({ ok: false, error: 'TOKEN_EXPIRED' });
+    expect(confirmSpentStore().size).toBe(0);
   });
 });

package/tests/tools/dispatch-gates.test.ts

@@ -24,9 +24,9 @@ const ORIGINAL_ENV = { ...process.env };
 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;
+  delete process.env.MCP_CONFIRM_MODE;
+  delete process.env.MCP_CONFIRM_TTL_SECONDS;
+  delete process.env.MCP_CONFIRM_SECRET;
   process.env.GOG_ACCOUNT = 'me@example.com';
   resetConfirmTokenState();
 });
@@ -75,15 +75,17 @@ describe('gog_chat_messages_send / gog_chat_dm_send', () => {
   });
 
   it('refuses a client that cannot be prompted, naming the fallback switch', async () => {
+
+    process.env.MCP_CONFIRM_MODE = 'refuse';
     const harness = await unprompted(registerChatTools);
     const r = json(await harness.callTool('gog_chat_messages_send', { space: 'spaces/AAA', text: 'x' }));
     expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'chat.message-send' });
-    expect(r.note).toContain('GOG_SEND_CONFIRM_FALLBACK=token');
+    expect(r.note).toContain('MCP_CONFIRM_MODE=ask-user');
     expect(runner.run).not.toHaveBeenCalled();
   });
 
   it('token fallback: previews in full, posts on phase 2, refuses a changed text', async () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
     stubReads({});
     const harness = await unprompted(registerChatTools);
     const args = { space: 'spaces/AAA', text: 'Ship it', attachInline: [{ filename: 'a.txt', contentBase64: Buffer.from('hey').toString('base64') }] };
@@ -137,15 +139,17 @@ describe('gog_drive_share', () => {
   });
 
   it('refuses a client that cannot be prompted, and says how the user can share it', async () => {
+
+    process.env.MCP_CONFIRM_MODE = 'refuse';
     stubReads({ 'drive get': FILE });
     const harness = await unprompted(registerDriveTools);
     const r = json(await harness.callTool('gog_drive_share', { fileId: 'f1', to: 'domain', domain: 'example.com' }));
     expect(r.note).toMatch(/share it themselves from Google Drive/);
-    expect(r.note).toContain('GOG_SEND_CONFIRM_FALLBACK=token');
+    expect(r.note).toContain('MCP_CONFIRM_MODE=ask-user');
   });
 
   it('token fallback: binds the file as read — a renamed file is DRAFT_CHANGED', async () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
     stubReads({ 'drive get': FILE });
     const harness = await unprompted(registerDriveTools);
     const args = { fileId: 'f1', to: 'anyone' as const };
@@ -189,6 +193,8 @@ describe('gog_classroom_announcements_create', () => {
   });
 
   it('refuses a client that cannot be prompted, pointing at DRAFT', async () => {
+
+    process.env.MCP_CONFIRM_MODE = 'refuse';
     stubReads({ 'classroom courses get': COURSE });
     const harness = await unprompted(registerClassroomTools);
     const r = json(await harness.callTool('gog_classroom_announcements_create', { courseId: 'c1', text: 'x' }));
@@ -197,7 +203,7 @@ describe('gog_classroom_announcements_create', () => {
   });
 
   it('token fallback: phase 1 previews, phase 2 posts', async () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
     stubReads({ 'classroom courses get': COURSE });
     const harness = await unprompted(registerClassroomTools);
     const p1 = json(await harness.callTool('gog_classroom_announcements_create', { courseId: 'c1', text: 'Quiz Friday' }));
@@ -264,6 +270,8 @@ describe('calendar', () => {
     });
 
     it('refuses a client that cannot be prompted, pointing at a guest-free create', async () => {
+
+      process.env.MCP_CONFIRM_MODE = 'refuse';
       const harness = await unprompted(registerCalendarTools);
       const r = json(await harness.callTool('gog_calendar_create', { calendarId: 'primary', summary: 'Sync', from: 'a', to: 'b', attendees: 'alice@example.com' }));
       expect(r.note).toMatch(/without attendees/);
@@ -271,7 +279,7 @@ describe('calendar', () => {
     });
 
     it('token fallback: previews, then creates on phase 2', async () => {
-      process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+      process.env.MCP_CONFIRM_MODE = 'ask-user';
       stubReads({});
       const harness = await unprompted(registerCalendarTools);
       const args = { calendarId: 'primary', summary: 'Sync', from: 'a', to: 'b', attendees: 'alice@example.com' };
@@ -335,7 +343,7 @@ describe('calendar', () => {
     });
 
     it('token fallback: an event edited elsewhere between the phases (etag rotated) is DRAFT_CHANGED', async () => {
-      process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+      process.env.MCP_CONFIRM_MODE = 'ask-user';
       stubReads({ 'calendar event': EVENT() });
       const harness = await unprompted(registerCalendarTools);
       const args = { calendarId: 'primary', eventId: 'e1', summary: 'Budget review (moved)' };
@@ -343,7 +351,7 @@ describe('calendar', () => {
       expect(p1.status).toBe('confirmation-required');
       stubReads({ 'calendar event': EVENT({ etag: '"v2"' }) });
       expect(json(await harness.callTool('gog_calendar_update', { ...args, confirmToken: p1.confirmToken })))
-        .toMatchObject({ error: 'DRAFT_CHANGED', reason: 'message-id-rotated' });
+        .toMatchObject({ error: 'DRAFT_CHANGED', reason: 'revision-changed' });
       expect(callsTo('calendar', 'update')).toHaveLength(0);
     });
   });
@@ -358,6 +366,8 @@ describe('calendar', () => {
     });
 
     it('refuses a client that cannot be prompted', async () => {
+
+      process.env.MCP_CONFIRM_MODE = 'refuse';
       stubReads({ 'calendar event': EVENT() });
       const harness = await unprompted(registerCalendarTools);
       const r = json(await harness.callTool('gog_calendar_respond', { calendarId: 'primary', eventId: 'e1', status: 'accepted' }));
@@ -372,7 +382,7 @@ describe('calendar', () => {
     });
 
     it('token fallback: phase 2 records the response', async () => {
-      process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+      process.env.MCP_CONFIRM_MODE = 'ask-user';
       stubReads({ 'calendar event': EVENT() });
       const harness = await unprompted(registerCalendarTools);
       const args = { calendarId: 'primary', eventId: 'e1', status: 'tentative' as const };

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

@@ -23,9 +23,9 @@ 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;
+  delete process.env.MCP_CONFIRM_MODE;
+  delete process.env.MCP_CONFIRM_TTL_SECONDS;
+  delete process.env.MCP_CONFIRM_SECRET;
   process.env.GOG_ACCOUNT = 'me@example.com';
   fileRoot = mkdtempSync(join(tmpdir(), 'gct-roots-'));
   process.env.GOG_FILE_ROOTS = fileRoot;
@@ -58,24 +58,26 @@ const sendCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args
 
 describe('gog_gmail_send — token fallback', () => {
   it('elicitation supported: unchanged — prompts and sends, confirmToken or not', async () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
     vi.mocked(runner.run).mockResolvedValue(SENT);
     const harness = await withElicitation();
-    const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: 'gct1.not.real' });
+    const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: 'not-a-real-token' });
     expect(result.content[0]!.text).toBe(SENT);
     expect(sendCalls()).toHaveLength(1);
   });
 
-  it('unsupported + env unset: refuses, with the new hint', async () => {
+  it('unsupported + MCP_CONFIRM_MODE=refuse: refuses, naming the switch', async () => {
+
+    process.env.MCP_CONFIRM_MODE = 'refuse';
     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(body.note).toContain('Set MCP_CONFIRM_MODE=ask-user');
     expect(runner.run).not.toHaveBeenCalled();
   });
 
-  describe('unsupported + GOG_SEND_CONFIRM_FALLBACK=token', () => {
-    beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+  describe('unsupported + MCP_CONFIRM_MODE=ask-user', () => {
+    beforeEach(() => { process.env.MCP_CONFIRM_MODE = 'ask-user'; });
 
     it('phase 1 previews everything (Bcc included, full body) and sends nothing', async () => {
       const long = `${'x'.repeat(5000)}END`;
@@ -101,7 +103,7 @@ describe('gog_gmail_send — token fallback', () => {
         inReplyTo: 'm0',
         quotesOriginal: false,
       });
-      expect(body.confirmToken).toMatch(/^gct1\./);
+      expect(body.confirmToken).toMatch(/^mcpu\.token\.v1\./);
       expect(body.instruction).toMatch(/verbatim/);
       expect(runner.run).not.toHaveBeenCalled();
     });
@@ -185,7 +187,7 @@ describe.each([
   });
   const replyCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args[1] === subcommand);
 
-  beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+  beforeEach(() => { process.env.MCP_CONFIRM_MODE = 'ask-user'; });
 
   it('phase 1 previews the resolved recipients, Bcc, full body and In-Reply-To; nothing sent', async () => {
     vi.mocked(runner.run).mockResolvedValue(metadata());