gogcli-mcp 2.0.7 → 2.0.9

package/tests/runner.test.ts

@@ -24,7 +24,7 @@ describe('run', () => {
     expect(spawner).toHaveBeenCalledWith(
       'gog',
       ['--json', '--color=never', '--no-input', 'sheets', 'get', 'id1', 'A1'],
-      expect.objectContaining({ env: process.env }),
+      expect.objectContaining({ env: expect.any(Object) }),
     );
   });
 
@@ -206,6 +206,93 @@ describe('run', () => {
       .rejects.toThrow('gog not found');
   });
 
+  it('wraps ENOENT spawn errors with an install-or-set-GOG_PATH hint', async () => {
+    const spawner = vi.fn(() => {
+      const proc = new EventEmitter() as ReturnType<Spawner>;
+      (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stdout = new EventEmitter();
+      (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stderr = new EventEmitter();
+      setTimeout(() => {
+        const err = new Error('spawn gog ENOENT') as NodeJS.ErrnoException;
+        err.code = 'ENOENT';
+        proc.emit('error', err);
+      }, 0);
+      return proc;
+    }) as unknown as Spawner;
+    await expect(run(['sheets', 'get', 'id', 'A1'], { spawner }))
+      .rejects.toThrow(/gog executable not found.*Install gogcli.*GOG_PATH/s);
+  });
+
+  it('augments child PATH with common gogcli install dirs', async () => {
+    const spawner = makeSpawner(0, '{}');
+    const originalHome = process.env.HOME;
+    const originalPath = process.env.PATH;
+    process.env.HOME = '/Users/test';
+    process.env.PATH = '/usr/bin:/bin';
+    try {
+      await run(['sheets', 'metadata', 'id1'], { spawner });
+      const passedEnv = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv;
+      const passedPath = passedEnv.PATH!;
+      expect(passedPath).toContain('/usr/bin');
+      expect(passedPath).toContain('/opt/homebrew/bin');
+      expect(passedPath).toContain('/usr/local/bin');
+      expect(passedPath).toContain('/Users/test/.local/bin');
+      expect(passedPath).toContain('/Users/test/go/bin');
+    } finally {
+      if (originalHome === undefined) delete process.env.HOME;
+      else process.env.HOME = originalHome;
+      if (originalPath === undefined) delete process.env.PATH;
+      else process.env.PATH = originalPath;
+    }
+  });
+
+  it('does not duplicate dirs that are already on PATH', async () => {
+    const spawner = makeSpawner(0, '{}');
+    const originalPath = process.env.PATH;
+    process.env.PATH = '/opt/homebrew/bin:/usr/bin';
+    try {
+      await run(['sheets', 'metadata', 'id1'], { spawner });
+      const passedEnv = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv;
+      const passedPath = passedEnv.PATH!;
+      const homebrewCount = passedPath.split(':').filter(d => d === '/opt/homebrew/bin').length;
+      expect(homebrewCount).toBe(1);
+    } finally {
+      if (originalPath === undefined) delete process.env.PATH;
+      else process.env.PATH = originalPath;
+    }
+  });
+
+  it('augments PATH even when HOME is unset', async () => {
+    const spawner = makeSpawner(0, '{}');
+    const originalHome = process.env.HOME;
+    const originalPath = process.env.PATH;
+    delete process.env.HOME;
+    process.env.PATH = '/usr/bin';
+    try {
+      await run(['sheets', 'metadata', 'id1'], { spawner });
+      const passedEnv = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv;
+      const passedPath = passedEnv.PATH!;
+      expect(passedPath).toContain('/opt/homebrew/bin');
+      expect(passedPath).not.toContain('.local/bin');
+    } finally {
+      if (originalHome !== undefined) process.env.HOME = originalHome;
+      if (originalPath === undefined) delete process.env.PATH;
+      else process.env.PATH = originalPath;
+    }
+  });
+
+  it('handles empty PATH gracefully', async () => {
+    const spawner = makeSpawner(0, '{}');
+    const originalPath = process.env.PATH;
+    delete process.env.PATH;
+    try {
+      await run(['sheets', 'metadata', 'id1'], { spawner });
+      const passedEnv = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv;
+      expect(passedEnv.PATH).toContain('/opt/homebrew/bin');
+    } finally {
+      if (originalPath !== undefined) process.env.PATH = originalPath;
+    }
+  });
+
   it('ignores close event if error event already settled the promise', async () => {
     const spawner = vi.fn(() => {
       const proc = new EventEmitter() as ReturnType<Spawner>;
@@ -396,6 +483,65 @@ describe('run', () => {
     }
   });
 
+  it('strips GOOGLE_APPLICATION_CREDENTIALS and *_TOKEN/*_SECRET/*_API_KEY/*_PRIVATE_KEY vars', async () => {
+    const spawner = makeSpawner(0, '{}');
+    const snapshot = {
+      GOOGLE_APPLICATION_CREDENTIALS: process.env.GOOGLE_APPLICATION_CREDENTIALS,
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+      DB_PASSWORD_TOKEN: process.env.DB_PASSWORD_TOKEN,
+      AWS_SECRET: process.env.AWS_SECRET,
+      MY_PRIVATE_KEY: process.env.MY_PRIVATE_KEY,
+      BENIGN_VAR: process.env.BENIGN_VAR,
+    };
+    process.env.GOOGLE_APPLICATION_CREDENTIALS = '/path/to/sa.json';
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-secret';
+    process.env.DB_PASSWORD_TOKEN = 'secret';
+    process.env.AWS_SECRET = 'secret';
+    process.env.MY_PRIVATE_KEY = 'secret';
+    process.env.BENIGN_VAR = 'hello';
+    try {
+      await run(['docs', 'cat', 'id'], { spawner });
+      const envPassed = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv;
+      expect(envPassed.GOOGLE_APPLICATION_CREDENTIALS).toBeUndefined();
+      expect(envPassed.ANTHROPIC_API_KEY).toBeUndefined();
+      expect(envPassed.DB_PASSWORD_TOKEN).toBeUndefined();
+      expect(envPassed.AWS_SECRET).toBeUndefined();
+      expect(envPassed.MY_PRIVATE_KEY).toBeUndefined();
+      expect(envPassed.BENIGN_VAR).toBe('hello');
+    } finally {
+      for (const [k, v] of Object.entries(snapshot)) {
+        if (v === undefined) delete process.env[k];
+        else process.env[k] = v;
+      }
+    }
+  });
+
+  it('redacts Bearer with quoted/encoded characters', async () => {
+    const stderrLeak = 'http 401: header was Bearer eyJ.test+slash/equal=padding more text';
+    const spawner = makeSpawner(1, '', stderrLeak);
+    try {
+      await run(['gmail', 'get', 'm1'], { spawner });
+    } catch (e) {
+      const msg = (e as Error).message;
+      expect(msg).not.toContain('eyJ.test+slash/equal=padding');
+      expect(msg).toContain('[REDACTED]');
+    }
+  });
+
+  it('redacts bearer/refresh tokens and Google API keys from stderr surfaced to the client', async () => {
+    const stderrLeak = 'request failed: Authorization: Bearer ya29.a0Ad52N3-LEAKED-TOKEN-VALUE refresh 1//0eLEAKED-REFRESH key AIzaSyDdI0hCZtE6vySjMm-WEfRq3CPzqKqqsHI extra';
+    const spawner = makeSpawner(1, '', stderrLeak);
+    try {
+      await run(['gmail', 'get', 'm1'], { spawner });
+    } catch (e) {
+      const msg = (e as Error).message;
+      expect(msg).not.toContain('ya29.a0Ad52N3-LEAKED-TOKEN-VALUE');
+      expect(msg).not.toContain('1//0eLEAKED-REFRESH');
+      expect(msg).not.toContain('AIzaSyDdI0hCZtE6vySjMm-WEfRq3CPzqKqqsHI');
+      expect(msg).toContain('[REDACTED]');
+    }
+  });
+
   it('ignores timeout if close event already settled the promise', async () => {
     vi.useFakeTimers();
     const spawner = vi.fn(() => {

package/tests/tools/auth.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerAuthTools } from '../../src/tools/auth.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerAuthTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerAuthTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/calendar.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerCalendarTools } from '../../src/tools/calendar.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerCalendarTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerCalendarTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/classroom.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerClassroomTools } from '../../src/tools/classroom.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerClassroomTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerClassroomTools);
 
 let handlers: Map<string, ToolHandler>;
 

package/tests/tools/contacts.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerContactsTools } from '../../src/tools/contacts.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerContactsTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerContactsTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/docs.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerDocsTools } from '../../src/tools/docs.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerDocsTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerDocsTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/drive.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerDriveTools } from '../../src/tools/drive.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerDriveTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerDriveTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/gmail.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerGmailTools } from '../../src/tools/gmail.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerGmailTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerGmailTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/sheets.test.ts

@@ -1,22 +1,11 @@
 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';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerSheetsTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerSheetsTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/slides.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerSlidesTools } from '../../src/tools/slides.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerSlidesTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerSlidesTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/tasks.test.ts

@@ -1,22 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerTasksTools } from '../../src/tools/tasks.js';
 import * as runner from '../../src/runner.js';
+import { setupHandlers as setupHandlersBase, type ToolHandler } from '../helpers/test-harness.js';
 
 vi.mock('../../src/runner.js');
 
-type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-
-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;
-  });
-  registerTasksTools(server);
-  return handlers;
-}
+const setupHandlers = () => setupHandlersBase(registerTasksTools);
 
 beforeEach(() => vi.clearAllMocks());
 

package/tests/tools/utils.test.ts

@@ -1,11 +1,45 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as runner from '../../src/runner.js';
-import { runOrDiagnose } from '../../src/tools/utils.js';
+import { runOrDiagnose, pushPaginationFlags } from '../../src/tools/utils.js';
 
 vi.mock('../../src/runner.js');
 
 beforeEach(() => vi.clearAllMocks());
 
+describe('pushPaginationFlags', () => {
+  it('does nothing when no fields are provided', () => {
+    const args: string[] = ['cmd'];
+    pushPaginationFlags(args, {});
+    expect(args).toEqual(['cmd']);
+  });
+
+  it('pushes --max when a number is provided (including 0)', () => {
+    const args: string[] = ['cmd'];
+    pushPaginationFlags(args, { max: 0 });
+    expect(args).toEqual(['cmd', '--max=0']);
+  });
+
+  it('pushes --page when a string is provided', () => {
+    const args: string[] = ['cmd'];
+    pushPaginationFlags(args, { page: 'tok' });
+    expect(args).toEqual(['cmd', '--page=tok']);
+  });
+
+  it('pushes --all only when true', () => {
+    const args: string[] = ['cmd'];
+    pushPaginationFlags(args, { all: false });
+    expect(args).toEqual(['cmd']);
+    pushPaginationFlags(args, { all: true });
+    expect(args).toEqual(['cmd', '--all']);
+  });
+
+  it('pushes all three in canonical order', () => {
+    const args: string[] = ['cmd'];
+    pushPaginationFlags(args, { max: 50, page: 'tok', all: true });
+    expect(args).toEqual(['cmd', '--max=50', '--page=tok', '--all']);
+  });
+});
+
 describe('runOrDiagnose', () => {
   it('returns output text on success', async () => {
     vi.mocked(runner.run).mockResolvedValue('{"ok":true}');