gogcli-mcp 2.8.0 → 2.18.0

package/tests/runner-file-args.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { run, isGogFileArg } from '../src/runner.js';
+import type { Spawner, GogArg } from '../src/runner.js';
+import { payloadArg, PAYLOAD_INLINE_MAX } from '../src/tools/utils.js';
+
+// These tests deliberately use the REAL fs: the whole point is that the bytes
+// gog would read off disk are byte-identical to the payload, and that the temp
+// dir is actually gone afterwards.
+
+interface Capture {
+  /** argv gog was spawned with. */
+  argv: string[];
+  /** Contents read back off disk WHILE the child was "running". */
+  files: Record<string, string>;
+  /** Temp dirs observed in the argv, captured before cleanup ran. */
+  dirs: string[];
+}
+
+/**
+ * A Spawner stub that, at spawn time, reads every `--x-file=<path>` arg back
+ * off disk. Reading inside the spawner is load-bearing: by the time `run()`
+ * resolves, the temp dir has already been removed.
+ */
+function makeCapturingSpawner(
+  exitCode: number,
+  stdout = '',
+  stderr = '',
+): { spawner: Spawner; capture: Capture } {
+  const capture: Capture = { argv: [], files: {}, dirs: [] };
+  const spawner = vi.fn((_cmd: string, argv: string[]) => {
+    capture.argv = argv;
+    for (const arg of argv) {
+      const match = /^--([^=]+-file)=(.*)$/s.exec(arg);
+      if (!match) continue;
+      capture.files[match[1]] = readFileSync(match[2], 'utf8');
+      capture.dirs.push(dirname(match[2]));
+    }
+    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();
+    proc.kill = vi.fn();
+    setTimeout(() => {
+      (proc as unknown as { stdout: EventEmitter }).stdout.emit('data', Buffer.from(stdout));
+      (proc as unknown as { stderr: EventEmitter }).stderr.emit('data', Buffer.from(stderr));
+      proc.emit('close', exitCode);
+    }, 0);
+    return proc;
+  }) as unknown as Spawner;
+  return { spawner, capture };
+}
+
+/** A stub that never emits close, so the timeout path fires. */
+function makeHangingSpawner(capture: Capture): Spawner {
+  return vi.fn((_cmd: string, argv: string[]) => {
+    capture.argv = argv;
+    for (const arg of argv) {
+      const match = /^--([^=]+-file)=(.*)$/s.exec(arg);
+      if (!match) continue;
+      capture.files[match[1]] = readFileSync(match[2], 'utf8');
+      capture.dirs.push(dirname(match[2]));
+    }
+    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();
+    proc.kill = vi.fn();
+    return proc;
+  }) as unknown as Spawner;
+}
+
+const big = (n: number) => 'x'.repeat(n);
+
+describe('payloadArg', () => {
+  it('keeps a small value on the inline flag verbatim', () => {
+    const arg = payloadArg('body-html', 'body-html-file', '<p>hi</p>', 'html');
+    expect(arg).toBe('--body-html=<p>hi</p>');
+  });
+
+  it('keeps a value exactly at the threshold inline', () => {
+    const value = big(PAYLOAD_INLINE_MAX);
+    expect(payloadArg('body', 'body-file', value)).toBe(`--body=${value}`);
+  });
+
+  it('switches to a file arg one byte over the threshold', () => {
+    const value = big(PAYLOAD_INLINE_MAX + 1);
+    expect(payloadArg('body-html', 'body-html-file', value, 'html')).toEqual({
+      kind: 'file',
+      flag: 'body-html-file',
+      contents: value,
+      ext: 'html',
+    });
+  });
+
+  it('leaves ext undefined when not supplied, so the runner defaults it', () => {
+    const arg = payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1));
+    expect(arg).toMatchObject({ kind: 'file', flag: 'body-file', ext: undefined });
+  });
+
+  // A char-based check would let ~3x the byte budget through. Measure bytes.
+  it('measures BYTES not characters for multibyte payloads', () => {
+    // '—' (em dash) is 3 bytes in UTF-8. Just over the byte cap, well under it
+    // by character count.
+    const value = '—'.repeat(Math.floor(PAYLOAD_INLINE_MAX / 3) + 1);
+    expect(value.length).toBeLessThanOrEqual(PAYLOAD_INLINE_MAX);
+    expect(Buffer.byteLength(value, 'utf8')).toBeGreaterThan(PAYLOAD_INLINE_MAX);
+    expect(isGogFileArg(payloadArg('body', 'body-file', value))).toBe(true);
+  });
+});
+
+describe('run with GogFileArgs', () => {
+  it('substitutes a file arg with a real path whose file holds the exact bytes', async () => {
+    const body = big(PAYLOAD_INLINE_MAX + 1);
+    const { spawner, capture } = makeCapturingSpawner(0, '{"ok":true}');
+
+    await run(['gmail', 'drafts', 'create', payloadArg('body-html', 'body-html-file', body, 'html')], { spawner });
+
+    const fileArg = capture.argv.find((a) => a.startsWith('--body-html-file='))!;
+    expect(fileArg).toBeDefined();
+    const path = fileArg.slice('--body-html-file='.length);
+    expect(path).not.toContain(body);
+    expect(path.endsWith('.html')).toBe(true);
+    expect(capture.files['body-html-file']).toBe(body);
+  });
+
+  it('defaults the temp-file extension to txt when ext is omitted', async () => {
+    const { spawner, capture } = makeCapturingSpawner(0, '{}');
+    await run(['gmail', 'send', { kind: 'file', flag: 'body-file', contents: 'hello' }], { spawner });
+    const fileArg = capture.argv.find((a) => a.startsWith('--body-file='))!;
+    expect(fileArg.endsWith('.txt')).toBe(true);
+  });
+
+  it('round-trips UTF-8 punctuation byte-for-byte through the temp file', async () => {
+    // The characters an LLM-authored mail body actually contains, and the ones
+    // a lossy encoding step would mangle first.
+    const tricky = 'em—dash en–dash minus−sign “curly” ‘quotes’ ellipsis… ✓ 日本語 🎉';
+    const body = tricky + '\n' + big(PAYLOAD_INLINE_MAX) + '\n' + tricky;
+    const { spawner, capture } = makeCapturingSpawner(0, '{}');
+
+    await run(['gmail', 'send', payloadArg('body-html', 'body-html-file', body, 'html')], { spawner });
+
+    expect(capture.files['body-html-file']).toBe(body);
+    expect(Buffer.from(capture.files['body-html-file'], 'utf8')).toEqual(Buffer.from(body, 'utf8'));
+  });
+
+  it('writes each file arg to its own path when one command carries two payloads', async () => {
+    // --body-file and --signature-file share the .txt extension; a fixed
+    // basename would have the second clobber the first.
+    const bodyText = 'BODY ' + big(PAYLOAD_INLINE_MAX);
+    const sigText = 'SIG ' + big(PAYLOAD_INLINE_MAX);
+    const { spawner, capture } = makeCapturingSpawner(0, '{}');
+
+    await run([
+      'gmail', 'send',
+      payloadArg('body', 'body-file', bodyText),
+      payloadArg('signature', 'signature-file', sigText),
+    ], { spawner });
+
+    expect(capture.files['body-file']).toBe(bodyText);
+    expect(capture.files['signature-file']).toBe(sigText);
+  });
+
+  it('leaves plain string args untouched alongside a file arg', async () => {
+    const { spawner, capture } = makeCapturingSpawner(0, '{}');
+    await run([
+      'gmail', 'drafts', 'create',
+      '--to=a@b.com',
+      payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1)),
+      '--subject=Hi',
+    ], { spawner });
+
+    expect(capture.argv.slice(0, 6)).toEqual([
+      '--json', '--color=never', '--no-input', 'gmail', 'drafts', 'create',
+    ]);
+    expect(capture.argv).toContain('--to=a@b.com');
+    expect(capture.argv).toContain('--subject=Hi');
+  });
+
+  it('removes the temp dir after a successful run', async () => {
+    const { spawner, capture } = makeCapturingSpawner(0, '{"ok":true}');
+    await run(['gmail', 'send', payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1))], { spawner });
+    expect(capture.dirs).toHaveLength(1);
+    expect(existsSync(capture.dirs[0])).toBe(false);
+  });
+
+  it('removes the temp dir after gog exits non-zero', async () => {
+    const { spawner, capture } = makeCapturingSpawner(1, '', 'gog: boom');
+    await expect(
+      run(['gmail', 'send', payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1))], { spawner }),
+    ).rejects.toThrow('gog: boom');
+    expect(capture.dirs).toHaveLength(1);
+    expect(existsSync(capture.dirs[0])).toBe(false);
+  });
+
+  it('removes the temp dir after a timeout', async () => {
+    // Real timers with a tiny timeout, deliberately: the temp file is written
+    // with real fs IO before the spawn, and vitest's fake timers can't advance
+    // past a pending IO callback to reach the timeout that is armed after it.
+    const capture: Capture = { argv: [], files: {}, dirs: [] };
+    const spawner = makeHangingSpawner(capture);
+
+    await expect(
+      run(['gmail', 'send', payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1))], {
+        spawner,
+        timeout: 20,
+      }),
+    ).rejects.toThrow('gog timed out after 20ms');
+
+    expect(capture.dirs).toHaveLength(1);
+    expect(existsSync(capture.dirs[0])).toBe(false);
+  });
+
+  it('forwards GogFileArgs unmaterialized to an injected executor', async () => {
+    // The hosted (Worker/Fly) executor does its own materialization on the
+    // remote side, so run() must hand it the union, not a local path.
+    const { runExecutor } = await import('../src/runner.js');
+    let seen: GogArg[] = [];
+    const executor = vi.fn(async (args: GogArg[]) => { seen = args; return '{}'; });
+    await runExecutor.run({ executor }, () =>
+      run(['gmail', 'send', payloadArg('body', 'body-file', big(PAYLOAD_INLINE_MAX + 1))], {}),
+    );
+    expect(seen.at(-1)).toMatchObject({ kind: 'file', flag: 'body-file' });
+  });
+});
+
+describe('isGogFileArg', () => {
+  it('distinguishes plain strings from file args', () => {
+    expect(isGogFileArg('--body=hi')).toBe(false);
+    expect(isGogFileArg({ kind: 'file', flag: 'body-file', contents: 'hi' })).toBe(true);
+  });
+});

package/tests/runner.test.ts

@@ -1,20 +1,28 @@
 import { describe, it, expect, vi } from 'vitest';
 import { EventEmitter } from 'node:events';
-import { run } from '../src/runner.js';
-import type { Spawner } from '../src/runner.js';
+import { spawn as mockedSpawn } from 'node:child_process';
+import { run, runBinary, runExecutor } from '../src/runner.js';
+import type { Spawner, GogExecutor } from '../src/runner.js';
+
+// The real spawn is dynamically imported inside runner's default executor.
+// Mock it so the no-spawner/no-executor fallback can be exercised without
+// touching a real `gog` binary.
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+
+function makeProc(exitCode: number, stdout = '', stderr = ''): ReturnType<Spawner> {
+  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(() => {
+    (proc as unknown as { stdout: EventEmitter }).stdout.emit('data', Buffer.from(stdout));
+    (proc as unknown as { stderr: EventEmitter }).stderr.emit('data', Buffer.from(stderr));
+    proc.emit('close', exitCode);
+  }, 0);
+  return proc;
+}
 
 function makeSpawner(exitCode: number, stdout = '', stderr = ''): Spawner {
-  return 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(() => {
-      (proc as unknown as { stdout: EventEmitter }).stdout.emit('data', Buffer.from(stdout));
-      (proc as unknown as { stderr: EventEmitter }).stderr.emit('data', Buffer.from(stderr));
-      proc.emit('close', exitCode);
-    }, 0);
-    return proc;
-  }) as unknown as Spawner;
+  return vi.fn(() => makeProc(exitCode, stdout, stderr)) as unknown as Spawner;
 }
 
 describe('run', () => {
@@ -542,6 +550,72 @@ describe('run', () => {
     }
   });
 
+  it('redacts Google tokens from SUCCESS stdout surfaced to the client', async () => {
+    // A successful `gog auth ... ` that echoes credentials (e.g. a token dump)
+    // must not leak them into model context on the resolve path.
+    const stdoutLeak =
+      '{"access_token":"ya29.a0Ad52N3-LEAKED-SUCCESS-TOKEN","refresh_token":"1//0eLEAKED-SUCCESS-REFRESH"}';
+    const spawner = makeSpawner(0, stdoutLeak, '');
+    const out = await run(['auth', 'list'], { spawner });
+    expect(out).not.toContain('ya29.a0Ad52N3-LEAKED-SUCCESS-TOKEN');
+    expect(out).not.toContain('1//0eLEAKED-SUCCESS-REFRESH');
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it('redacts Google tokens from interactive SUCCESS stdout+stderr', async () => {
+    const spawner = makeSpawner(0, 'token ya29.a0Ad52N3-INTERACTIVE-LEAK done', 'note line');
+    const out = await run(['auth', 'add', 'x@y.com'], { spawner, interactive: true });
+    expect(out).not.toContain('ya29.a0Ad52N3-INTERACTIVE-LEAK');
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it("redactMode 'tokens' preserves OAuth scope names the shared redactor mangles", async () => {
+    // The shared redactor treats a `classroom.coursework.students` scope as a
+    // secret and replaces it — corrupting a step-1 auth URL. 'tokens' mode must
+    // leave scope names intact.
+    const authUrl =
+      'https://accounts.google.com/o/oauth2/auth?scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fclassroom.coursework.students+openid&state=abc123';
+    const spawner = makeSpawner(0, JSON.stringify({ auth_url: authUrl }), '');
+    const full = await run(['auth', 'add'], { spawner });
+    expect(full).toContain('[REDACTED]'); // full mode mangles the scope
+    const spawner2 = makeSpawner(0, JSON.stringify({ auth_url: authUrl }), '');
+    const tokensOnly = await run(['auth', 'add'], { spawner: spawner2, redactMode: 'tokens' });
+    expect(tokensOnly).toContain('classroom.coursework.students');
+    expect(tokensOnly).not.toContain('[REDACTED]');
+  });
+
+  it("redactMode 'tokens' still strips real Google tokens", async () => {
+    const leak = 'url with token ya29.a0Ad52N3-STEP-LEAK and refresh 1//0eSTEP-REFRESH-LEAK';
+    const spawner = makeSpawner(0, leak, '');
+    const out = await run(['auth', 'add'], { spawner, redactMode: 'tokens' });
+    expect(out).not.toContain('ya29.a0Ad52N3-STEP-LEAK');
+    expect(out).not.toContain('1//0eSTEP-REFRESH-LEAK');
+    expect(out).toContain('[REDACTED]');
+  });
+
+  it("redactMode 'tokens' strips tokens from thrown error text too", async () => {
+    const spawner = makeSpawner(1, '', 'boom ya29.a0Ad52N3-ERR-LEAK end');
+    await expect(run(['auth', 'add'], { spawner, redactMode: 'tokens' })).rejects.toThrow('[REDACTED]');
+  });
+
+  it('runBinary returns stdout base64-encoded, not the raw string', async () => {
+    const spawner = makeSpawner(0, '%PDF-1.4 body');
+    const out = await runBinary(['api', 'call', 'drive', 'v3', 'files.get'], { spawner });
+    expect(out).toBe(Buffer.from('%PDF-1.4 body').toString('base64'));
+    expect(out).not.toBe('%PDF-1.4 body'); // base64, so bytes survive intact
+    const callArgs = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][1] as string[];
+    expect(callArgs).toContain('--json');
+    expect(callArgs).toContain('files.get');
+  });
+
+  it('runBinary refuses over the hosted-connector forward executor', async () => {
+    const executor = vi.fn();
+    await expect(
+      runExecutor.run({ executor }, () => runBinary(['api', 'call', 'drive', 'v3', 'files.get'])),
+    ).rejects.toThrow('not available over the hosted connector');
+    expect(executor).not.toHaveBeenCalled();
+  });
+
   it('ignores timeout if close event already settled the promise', async () => {
     vi.useFakeTimers();
     const spawner = vi.fn(() => {
@@ -569,3 +643,137 @@ describe('run', () => {
     vi.useRealTimers();
   });
 });
+
+describe('run --readonly (gog 0.31)', () => {
+  function withReadonlyEnv<T>(value: string | undefined, fn: () => T): T {
+    const original = process.env.GOG_READONLY;
+    if (value === undefined) delete process.env.GOG_READONLY;
+    else process.env.GOG_READONLY = value;
+    try {
+      return fn();
+    } finally {
+      if (original === undefined) delete process.env.GOG_READONLY;
+      else process.env.GOG_READONLY = original;
+    }
+  }
+
+  it('injects --readonly when options.readonly is true', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv(undefined, () => run(['drive', 'list'], { readonly: true, spawner }));
+    expect(spawner).toHaveBeenCalledWith(
+      'gog',
+      ['--json', '--color=never', '--no-input', '--readonly', 'drive', 'list'],
+      expect.any(Object),
+    );
+  });
+
+  it('injects --readonly when GOG_READONLY is set to a truthy value', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv('1', () => run(['drive', 'list'], { spawner }));
+    expect(spawner).toHaveBeenCalledWith(
+      'gog',
+      ['--json', '--color=never', '--no-input', '--readonly', 'drive', 'list'],
+      expect.any(Object),
+    );
+  });
+
+  it('does not inject --readonly when GOG_READONLY is an explicit off value', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv('false', () => run(['drive', 'list'], { spawner }));
+    expect(spawner).toHaveBeenCalledWith(
+      'gog',
+      ['--json', '--color=never', '--no-input', 'drive', 'list'],
+      expect.any(Object),
+    );
+  });
+
+  it('does not inject --readonly by default', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv(undefined, () => run(['drive', 'list'], { spawner }));
+    const call = (spawner as unknown as { mock: { calls: unknown[][] } }).mock.calls[0]!;
+    expect(call[1]).not.toContain('--readonly');
+  });
+
+  // GOG_READONLY is fail-safe: an unrecognised (but set) value blocks writes
+  // rather than silently allowing them.
+  it('injects --readonly when GOG_READONLY is set to an unrecognised value', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv('enable-please', () => run(['drive', 'list'], { spawner }));
+    const call = (spawner as unknown as { mock: { calls: unknown[][] } }).mock.calls[0]!;
+    expect(call[1]).toContain('--readonly');
+  });
+
+  it('does not inject --readonly when GOG_READONLY is an unresolved .mcpb placeholder', async () => {
+    const spawner = makeSpawner(0, '{}');
+    await withReadonlyEnv('${user_config.gog_readonly}', () => run(['drive', 'list'], { spawner }));
+    const call = (spawner as unknown as { mock: { calls: unknown[][] } }).mock.calls[0]!;
+    expect(call[1]).not.toContain('--readonly');
+  });
+});
+
+describe('run executor seam', () => {
+  it('routes to an injected runExecutor executor when no options.spawner is given', async () => {
+    const executor = vi.fn(async () => '{"via":"executor"}') as unknown as GogExecutor;
+    const result = await runExecutor.run({ executor }, () => run(['sheets', 'get', 'id1', 'A1']));
+    expect(result).toBe('{"via":"executor"}');
+    // The executor receives the FULLY-ASSEMBLED gog arg list plus the run opts.
+    expect(executor).toHaveBeenCalledWith(
+      ['--json', '--color=never', '--no-input', 'sheets', 'get', 'id1', 'A1'],
+      { timeout: undefined, interactive: false },
+    );
+  });
+
+  it('forwards timeout and interactive through to the injected executor', async () => {
+    const executor = vi.fn(async () => '{}') as unknown as GogExecutor;
+    await runExecutor.run({ executor }, () =>
+      run(['auth', 'add', 'u@g.com'], { interactive: true, timeout: 60_000 }),
+    );
+    expect(executor).toHaveBeenCalledWith(
+      ['--json', '--color=never', 'auth', 'add', 'u@g.com'],
+      { timeout: 60_000, interactive: true },
+    );
+  });
+
+  it('redacts Google tokens returned by an injected executor', async () => {
+    const executor = vi.fn(async () => 'token ya29.a0Ad52N3-ALS-LEAK done') as unknown as GogExecutor;
+    const result = await runExecutor.run({ executor }, () => run(['auth', 'list']));
+    expect(result).not.toContain('ya29.a0Ad52N3-ALS-LEAK');
+    expect(result).toContain('[REDACTED]');
+  });
+
+  it('redacts error text thrown by an injected executor', async () => {
+    const executor = vi.fn(async () => {
+      throw new Error('boom 1//0eALS-REFRESH-LEAK end');
+    }) as unknown as GogExecutor;
+    try {
+      await runExecutor.run({ executor }, () => run(['gmail', 'get', 'm1']));
+      throw new Error('expected rejection');
+    } catch (e) {
+      const msg = (e as Error).message;
+      expect(msg).not.toContain('1//0eALS-REFRESH-LEAK');
+      expect(msg).toContain('[REDACTED]');
+    }
+  });
+
+  it('options.spawner takes precedence over an injected ALS executor', async () => {
+    const spawner = makeSpawner(0, '{"via":"spawner"}');
+    const executor = vi.fn(async () => '{"via":"executor"}') as unknown as GogExecutor;
+    const result = await runExecutor.run({ executor }, () =>
+      run(['sheets', 'get', 'id1', 'A1'], { spawner }),
+    );
+    expect(result).toBe('{"via":"spawner"}');
+    expect(executor).not.toHaveBeenCalled();
+    expect(spawner).toHaveBeenCalledOnce();
+  });
+
+  it('falls back to the lazily-imported real spawn when neither a spawner nor an ALS executor is set', async () => {
+    vi.mocked(mockedSpawn).mockImplementation((() => makeProc(0, '{"real":true}')) as never);
+    const result = await run(['sheets', 'get', 'id1', 'A1']);
+    expect(result).toBe('{"real":true}');
+    expect(mockedSpawn).toHaveBeenCalledWith(
+      'gog',
+      ['--json', '--color=never', '--no-input', 'sheets', 'get', 'id1', 'A1'],
+      expect.objectContaining({ env: expect.any(Object) }),
+    );
+  });
+});

package/tests/server.test.ts

@@ -1,33 +1,33 @@
 import { describe, it, expect } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { createServer, createBaseServer, VERSION } from '../src/server.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+import { BASE_TOOL_REGISTRARS, VERSION } from '../src/server.js';
 
-describe('createServer', () => {
-  it('returns an McpServer with default name and version', () => {
-    const server = createServer();
-    expect(server).toBeInstanceOf(McpServer);
-  });
-
-  it('accepts custom name and version', () => {
-    const server = createServer({ name: 'custom', version: '9.9.9' });
-    expect(server).toBeInstanceOf(McpServer);
-  });
-
-  it('accepts partial options (name only)', () => {
-    const server = createServer({ name: 'partial' });
-    expect(server).toBeInstanceOf(McpServer);
-  });
-});
-
-describe('createBaseServer', () => {
-  it('returns an McpServer with all services registered', () => {
-    const server = createBaseServer();
-    expect(server).toBeInstanceOf(McpServer);
-  });
-
-  it('accepts custom options', () => {
-    const server = createBaseServer({ name: 'gogcli-all', version: '9.9.9' });
-    expect(server).toBeInstanceOf(McpServer);
+describe('BASE_TOOL_REGISTRARS', () => {
+  it('registers every base service without duplicate tool names', async () => {
+    const harness = await createTestHarness((server) => {
+      for (const register of BASE_TOOL_REGISTRARS) {
+        register(server, undefined);
+      }
+    });
+    const names = (await harness.listTools()).map((t) => t.name);
+    expect(new Set(names).size).toBe(names.length);
+    // One representative tool per service registrar, in registrar order.
+    for (const expected of [
+      'gog_api_list',
+      'gog_auth_list',
+      'gog_calendar_events',
+      'gog_classroom_courses_list',
+      'gog_contacts_list',
+      'gog_docs_cat',
+      'gog_drive_ls',
+      'gog_gmail_search',
+      'gog_sheets_get',
+      'gog_slides_export',
+      'gog_tasks_lists',
+    ]) {
+      expect(names).toContain(expected);
+    }
+    await harness.close();
   });
 });
 

package/tests/tools/api.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerApiTools } from '../../src/tools/api.js';
+import * as runner from '../../src/runner.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+
+vi.mock('../../src/runner.js');
+
+const setupHandlers = () => createTestHarness(registerApiTools);
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('gog_api_list', () => {
+  it('lists the default API set', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_list', {});
+    expect(runner.run).toHaveBeenCalledWith(['api', 'list'], { account: undefined });
+  });
+
+  it('adds --all when requested', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_list', { all: true });
+    expect(runner.run).toHaveBeenCalledWith(['api', 'list', '--all'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('List failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_api_list', {});
+    expect(result.content[0].text).toBe('Error: List failed');
+  });
+});
+
+describe('gog_api_describe', () => {
+  it('describes a whole API', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_describe', { api: 'drive', version: 'v3' });
+    expect(runner.run).toHaveBeenCalledWith(['api', 'describe', 'drive', 'v3'], { account: undefined });
+  });
+
+  it('describes a single method when method is provided', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_describe', { api: 'drive', version: 'v3', method: 'files.list' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['api', 'describe', 'drive', 'v3', 'files.list'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Describe failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_api_describe', { api: 'x', version: 'v1' });
+    expect(result.content[0].text).toBe('Error: Describe failed');
+  });
+});
+
+describe('gog_api_call', () => {
+  it('calls a read method with params', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_call', { api: 'drive', version: 'v3', method: 'files.list', params: '{"q":"x"}' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['api', 'call', 'drive', 'v3', 'files.list', '--params={"q":"x"}'],
+      { account: undefined },
+    );
+  });
+
+  it('passes body, scope, allow-write and dry-run for a write method', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_call', {
+      api: 'drive', version: 'v3', method: 'files.create',
+      params: '{"fields":"id"}', body: '{"name":"f"}', scope: 'https://www.googleapis.com/auth/drive',
+      allowWrite: true, dryRun: true, account: 'a@b.com',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      [
+        'api', 'call', 'drive', 'v3', 'files.create',
+        '--params={"fields":"id"}', '--body={"name":"f"}',
+        '--scope=https://www.googleapis.com/auth/drive', '--allow-write', '--dry-run', '--force',
+      ],
+      { account: 'a@b.com' },
+    );
+  });
+
+  it('appends --force last even when dry-run is absent', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_api_call', {
+      api: 'drive', version: 'v3', method: 'files.create', allowWrite: true,
+    });
+    const passedArgs = vi.mocked(runner.run).mock.calls[0][0];
+    expect(passedArgs).toEqual(['api', 'call', 'drive', 'v3', 'files.create', '--allow-write', '--force']);
+    expect(passedArgs[passedArgs.length - 1]).toBe('--force');
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Call failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_api_call', { api: 'drive', version: 'v3', method: 'files.list' });
+    expect(result.content[0].text).toBe('Error: Call failed');
+  });
+});