gogcli-mcp 2.30.0 → 4.0.0

package/tests/bootstrap-auth.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventEmitter } from 'node:events';
+import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { bootstrapGogAuth, AUTH_BOOTSTRAP_MARKER } from '../src/bootstrap-auth.js';
+import type { Spawner } from '../src/runner.js';
+
+const FULL = {
+  GOG_CLIENT_ID: 'client-id.apps.googleusercontent.com',
+  GOG_CLIENT_SECRET: 'GOCSPX-client-secret-value',
+  GOG_REFRESH_TOKEN: '1//refresh-token-value',
+  GOG_ACCOUNT: 'someone@example.com',
+};
+
+function fingerprint(env: typeof FULL): string {
+  return createHash('sha256')
+    .update([env.GOG_CLIENT_ID, env.GOG_CLIENT_SECRET, env.GOG_REFRESH_TOKEN, env.GOG_ACCOUNT].join('\0'))
+    .digest('hex');
+}
+
+interface Call {
+  argv: string[];
+  env: NodeJS.ProcessEnv;
+  /** Contents of every temp-file path in argv, read while the child "runs". */
+  files: string[];
+}
+
+type Reply = { code: number; stdout?: string; stderr?: string } | { error: Error };
+
+function makeSpawner(reply: (argv: string[]) => Reply): { spawner: Spawner; calls: Call[] } {
+  const calls: Call[] = [];
+  const spawner = vi.fn((_cmd: string, argv: string[], opts: { env: NodeJS.ProcessEnv }) => {
+    const files = argv.filter((a) => a.includes('gogcli-mcp-') && existsSync(a)).map((p) => readFileSync(p, 'utf8'));
+    calls.push({ argv, env: opts.env, files });
+    const proc = new EventEmitter() as ReturnType<Spawner>;
+    const io = proc as unknown as { stdout: EventEmitter; stderr: EventEmitter };
+    io.stdout = new EventEmitter();
+    io.stderr = new EventEmitter();
+    proc.kill = vi.fn();
+    const r = reply(argv);
+    setTimeout(() => {
+      if ('error' in r) {
+        proc.emit('error', r.error);
+        return;
+      }
+      if (r.stdout) io.stdout.emit('data', Buffer.from(r.stdout));
+      if (r.stderr) io.stderr.emit('data', Buffer.from(r.stderr));
+      proc.emit('close', r.code);
+    }, 0);
+    return proc;
+  }) as unknown as Spawner;
+  return { spawner, calls };
+}
+
+const listing = (...emails: string[]): string => JSON.stringify({ accounts: emails.map((email) => ({ email })) });
+
+const isList = (argv: string[]): boolean => argv.includes('list');
+
+describe('bootstrapGogAuth', () => {
+  let home: string;
+  let stderr: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), 'bootstrap-auth-test-'));
+    stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    stderr.mockRestore();
+    rmSync(home, { recursive: true, force: true });
+  });
+
+  const stderrText = (): string => stderr.mock.calls.map((c: unknown[]) => String(c[0])).join('');
+
+  it('does nothing when none of the variables is set', async () => {
+    const { spawner, calls } = makeSpawner(() => ({ code: 0 }));
+    const status = await bootstrapGogAuth({}, { spawner, home });
+    expect(status).toBe('unconfigured');
+    expect(calls).toHaveLength(0);
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
+  it('treats blank and unresolved-placeholder values as unset', async () => {
+    const { spawner, calls } = makeSpawner(() => ({ code: 0 }));
+    const status = await bootstrapGogAuth(
+      { GOG_CLIENT_ID: '', GOG_CLIENT_SECRET: '${user_config.secret}', GOG_REFRESH_TOKEN: 'undefined', GOG_ACCOUNT: '  ' },
+      { spawner, home },
+    );
+    expect(status).toBe('unconfigured');
+    expect(calls).toHaveLength(0);
+  });
+
+  it('names the missing variables, and never a value, when only some are set', async () => {
+    const { spawner, calls } = makeSpawner(() => ({ code: 0 }));
+    const status = await bootstrapGogAuth(
+      { GOG_CLIENT_ID: FULL.GOG_CLIENT_ID, GOG_REFRESH_TOKEN: FULL.GOG_REFRESH_TOKEN },
+      { spawner, home },
+    );
+    expect(status).toBe('incomplete');
+    expect(calls).toHaveLength(0);
+    const out = stderrText();
+    expect(out).toContain('GOG_CLIENT_SECRET');
+    expect(out).toContain('GOG_ACCOUNT');
+    expect(out).not.toContain(FULL.GOG_CLIENT_ID);
+    expect(out).not.toContain(FULL.GOG_REFRESH_TOKEN);
+    expect(stderr).toHaveBeenCalledTimes(1);
+  });
+
+  it('imports credentials then the token, only via temp files, and writes a private marker', async () => {
+    const { spawner, calls } = makeSpawner(() => ({ code: 0, stdout: '{}' }));
+    const status = await bootstrapGogAuth({ ...FULL }, { spawner, home });
+    expect(status).toBe('imported');
+    expect(calls).toHaveLength(2);
+
+    const [creds, tokens] = calls;
+    expect(creds.argv).toEqual(expect.arrayContaining(['auth', 'credentials', 'set']));
+    expect(JSON.parse(creds.files[0])).toEqual({
+      installed: { client_id: FULL.GOG_CLIENT_ID, client_secret: FULL.GOG_CLIENT_SECRET },
+    });
+    expect(tokens.argv).toEqual(expect.arrayContaining(['auth', 'tokens', 'import']));
+    expect(JSON.parse(tokens.files[0])).toEqual({ email: FULL.GOG_ACCOUNT, refresh_token: FULL.GOG_REFRESH_TOKEN });
+
+    // The temp file is the LAST argv element: the positional <path> gog reads.
+    for (const call of calls) {
+      expect(call.files).toHaveLength(1);
+      expect(existsSync(call.argv[call.argv.length - 1])).toBe(false); // cleaned up afterwards
+      const argvText = call.argv.join(' ');
+      expect(argvText).not.toContain(FULL.GOG_CLIENT_SECRET);
+      expect(argvText).not.toContain(FULL.GOG_REFRESH_TOKEN);
+      const envText = JSON.stringify(call.env);
+      expect(envText).not.toContain(FULL.GOG_CLIENT_SECRET);
+      expect(envText).not.toContain(FULL.GOG_REFRESH_TOKEN);
+    }
+
+    const markerDir = join(home, '.gogcli-mcp');
+    const marker = join(markerDir, AUTH_BOOTSTRAP_MARKER);
+    expect(readFileSync(marker, 'utf8')).toBe(fingerprint(FULL));
+    expect(statSync(markerDir).mode & 0o777).toBe(0o700);
+    expect(statSync(marker).mode & 0o777).toBe(0o600);
+  });
+
+  it('reports present and does nothing when the marker matches and gog lists the account', async () => {
+    mkdirSync(join(home, '.gogcli-mcp'));
+    writeFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), fingerprint(FULL));
+    const { spawner, calls } = makeSpawner(() => ({ code: 0, stdout: listing('other@example.com', 'SomeOne@Example.com') }));
+    const status = await bootstrapGogAuth({ ...FULL }, { spawner, home });
+    expect(status).toBe('present');
+    expect(calls).toHaveLength(1);
+    expect(calls[0].argv).toEqual(expect.arrayContaining(['auth', 'list']));
+  });
+
+  it('re-imports when the marker matches but gog no longer lists the account', async () => {
+    mkdirSync(join(home, '.gogcli-mcp'));
+    writeFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), fingerprint(FULL));
+    const { spawner, calls } = makeSpawner((argv) => ({ code: 0, stdout: isList(argv) ? listing('other@example.com') : '{}' }));
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('imported');
+    expect(calls.map((c) => c.argv.includes('list'))).toEqual([true, false, false]);
+  });
+
+  it.each([
+    ['an unparseable listing', { code: 0, stdout: 'not json' }],
+    ['a listing without accounts', { code: 0, stdout: '{"accounts":null}' }],
+    ['a listing whose entries carry no email', { code: 0, stdout: '{"accounts":[{}]}' }],
+    ['a failing listing', { code: 1, stderr: 'keyring locked' }],
+  ])('re-imports when the marker matches but gog returns %s', async (_label, listReply) => {
+    mkdirSync(join(home, '.gogcli-mcp'));
+    writeFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), fingerprint(FULL));
+    const { spawner, calls } = makeSpawner((argv) => (isList(argv) ? listReply : { code: 0, stdout: '{}' }));
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('imported');
+    expect(calls).toHaveLength(3);
+  });
+
+  it('re-imports without listing when the secret was rotated (marker differs)', async () => {
+    mkdirSync(join(home, '.gogcli-mcp'));
+    writeFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), 'stale-fingerprint');
+    const { spawner, calls } = makeSpawner(() => ({ code: 0, stdout: '{}' }));
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('imported');
+    expect(calls).toHaveLength(2);
+    expect(calls.some((c) => c.argv.includes('list'))).toBe(false);
+    expect(readFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), 'utf8')).toBe(fingerprint(FULL));
+  });
+
+  it('fails without throwing, redacts, and writes no marker when gog rejects the import', async () => {
+    const { spawner } = makeSpawner((argv) =>
+      argv.includes('tokens')
+        ? { code: 1, stderr: `bad token ${FULL.GOG_REFRESH_TOKEN} for secret ${FULL.GOG_CLIENT_SECRET}` }
+        : { code: 0, stdout: '{}' },
+    );
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('failed');
+    const out = stderrText();
+    expect(stderr).toHaveBeenCalledTimes(1);
+    expect(out).toContain('bad token');
+    expect(out).not.toContain(FULL.GOG_REFRESH_TOKEN);
+    expect(out).not.toContain(FULL.GOG_CLIENT_SECRET);
+    expect(existsSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER))).toBe(false);
+  });
+
+  it('fails without throwing when gog is not installed', async () => {
+    const enoent = Object.assign(new Error('spawn gog ENOENT'), { code: 'ENOENT' });
+    const { spawner } = makeSpawner(() => ({ error: enoent }));
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('failed');
+    expect(stderrText()).toContain('gog executable not found');
+  });
+
+  it('fails without throwing when the marker cannot be written', async () => {
+    writeFileSync(join(home, '.gogcli-mcp'), 'a file where the directory should be');
+    const { spawner } = makeSpawner(() => ({ code: 0, stdout: '{}' }));
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner, home })).toBe('failed');
+    expect(stderr).toHaveBeenCalledTimes(1);
+  });
+
+  it('stringifies a non-Error failure', async () => {
+    const throwing = vi.fn(() => {
+      throw 'plain string failure';
+    }) as unknown as Spawner;
+    expect(await bootstrapGogAuth({ ...FULL }, { spawner: throwing, home })).toBe('failed');
+    expect(stderrText()).toContain('plain string failure');
+  });
+
+  it('puts the marker under the OS home directory by default', async () => {
+    const savedHome = process.env.HOME;
+    process.env.HOME = home;
+    try {
+      const { spawner } = makeSpawner(() => ({ code: 0, stdout: '{}' }));
+      expect(await bootstrapGogAuth({ ...FULL }, { spawner })).toBe('imported');
+      expect(readFileSync(join(home, '.gogcli-mcp', AUTH_BOOTSTRAP_MARKER), 'utf8')).toBe(fingerprint(FULL));
+    } finally {
+      process.env.HOME = savedHome;
+    }
+  });
+
+  it('defaults to process.env', async () => {
+    // With none of the four variables set the default path is a no-op, so this
+    // proves the defaults are wired without touching the real home directory.
+    const saved = Object.fromEntries(Object.keys(FULL).map((k) => [k, process.env[k]]));
+    for (const k of Object.keys(FULL)) delete process.env[k];
+    try {
+      expect(await bootstrapGogAuth()).toBe('unconfigured');
+    } finally {
+      for (const [k, v] of Object.entries(saved)) if (v !== undefined) process.env[k] = v;
+    }
+  });
+});

package/tests/gmail-dispatch-guard.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { rawTextResult } from '@chrischall/mcp-utils';
+import {
+  extractEmails,
+  logGmailDispatch,
+  resultText,
+} from '../src/gmail-dispatch-guard.js';
+
+describe('extractEmails', () => {
+  it('extracts a bare address', () => {
+    expect(extractEmails('a@example.com')).toEqual(['a@example.com']);
+  });
+
+  it('extracts multiple addresses from a display-name header value', () => {
+    expect(extractEmails('"Alice" <alice@example.com>, "Bob" <bob@example.org>'))
+      .toEqual(['alice@example.com', 'bob@example.org']);
+  });
+
+  it('lowercases and dedupes across multiple arguments', () => {
+    expect(extractEmails('Alice@Example.com', 'bob@x.com, alice@example.com'))
+      .toEqual(['alice@example.com', 'bob@x.com']);
+  });
+
+  it('ignores undefined, null, and empty-string inputs', () => {
+    expect(extractEmails(undefined, null, '', 'a@b.com')).toEqual(['a@b.com']);
+  });
+
+  it('returns an empty array when nothing looks like an email', () => {
+    expect(extractEmails('no addresses here', undefined)).toEqual([]);
+  });
+});
+
+describe('resultText', () => {
+  it('reads the text out of a CallToolResult', () => {
+    expect(resultText(rawTextResult('{"a":1}'))).toBe('{"a":1}');
+  });
+
+  it('falls back to an empty object for a non-text content block', () => {
+    expect(resultText({ content: [{ type: 'image', data: 'x', mimeType: 'image/png' }] })).toBe('{}');
+  });
+
+  it('falls back to an empty object when content is empty', () => {
+    expect(resultText({ content: [] })).toBe('{}');
+  });
+});
+
+describe('logGmailDispatch', () => {
+  const ORIGINAL_ENV = { ...process.env };
+  let writeSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+    delete process.env.GOG_GMAIL_TRUSTED_DOMAINS;
+    delete process.env.GOG_ACCOUNT;
+    writeSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    process.env = ORIGINAL_ENV;
+    writeSpy.mockRestore();
+  });
+
+  function loggedEvent(): Record<string, unknown> {
+    expect(writeSpy).toHaveBeenCalledTimes(1);
+    return JSON.parse((writeSpy.mock.calls[0][0] as string).trim());
+  }
+
+  it('logs a distinguishable gmail_dispatch event with the recipient count', () => {
+    logGmailDispatch('gog_gmail_send', ['a@example.com', 'b@example.com']);
+    const event = loggedEvent();
+    expect(event.event).toBe('gmail_dispatch');
+    expect(event.tool).toBe('gog_gmail_send');
+    expect(event.recipientCount).toBe(2);
+    expect(typeof event.timestamp).toBe('string');
+  });
+
+  it('treats the account\'s own domain as trusted by default', () => {
+    logGmailDispatch('gog_gmail_reply', ['me@example.com', 'outside@other.com'], 'me@example.com');
+    const event = loggedEvent();
+    expect(event.hasExternalRecipients).toBe(true);
+    expect(event.externalRecipients).toEqual(['outside@other.com']);
+    expect(event.externalRecipientCount).toBe(1);
+  });
+
+  it('falls back to GOG_ACCOUNT when no account param is passed', () => {
+    process.env.GOG_ACCOUNT = 'me@example.com';
+    logGmailDispatch('gog_gmail_send', ['me@example.com', 'outside@other.com']);
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual(['outside@other.com']);
+  });
+
+  it('adds every domain in GOG_GMAIL_TRUSTED_DOMAINS on top of the account domain', () => {
+    process.env.GOG_GMAIL_TRUSTED_DOMAINS = 'law-firm.example, partner.example';
+    logGmailDispatch('gog_gmail_reply_all', ['counsel@law-firm.example', 'stranger@random.example'], 'me@example.com');
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual(['stranger@random.example']);
+  });
+
+  it('reports no external recipients when every address is trusted', () => {
+    logGmailDispatch('gog_gmail_forward', ['me@example.com'], 'me@example.com');
+    const event = loggedEvent();
+    expect(event.hasExternalRecipients).toBe(false);
+    expect(event.externalRecipients).toEqual([]);
+  });
+
+  it('treats an account with no @ as contributing no trusted domain', () => {
+    logGmailDispatch('gog_gmail_send', ['a@example.com'], 'not-an-email');
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual(['a@example.com']);
+  });
+
+  it('ignores an empty segment in GOG_GMAIL_TRUSTED_DOMAINS (e.g. a trailing comma)', () => {
+    process.env.GOG_GMAIL_TRUSTED_DOMAINS = 'law-firm.example,,';
+    logGmailDispatch('gog_gmail_send', ['counsel@law-firm.example'], 'me@example.com');
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual([]);
+  });
+
+  it('treats unresolved desktop placeholders as unset env vars', () => {
+    process.env.GOG_GMAIL_TRUSTED_DOMAINS = '${user_config.trusted_domains}';
+    process.env.GOG_ACCOUNT = '${user_config.account}';
+    logGmailDispatch('gog_gmail_send', ['person@user_config.trusted_domains']);
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual(['person@user_config.trusted_domains']);
+  });
+
+  it('treats a recipient with no @ as external, not a crash', () => {
+    logGmailDispatch('gog_gmail_send', ['not-an-email'], 'me@example.com');
+    const event = loggedEvent();
+    expect(event.externalRecipients).toEqual(['not-an-email']);
+  });
+});

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

@@ -3,7 +3,7 @@ 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 type { Spawner } 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
@@ -210,18 +210,6 @@ describe('run with GogFileArgs', () => {
     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', () => {

package/tests/runner.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
 import { EventEmitter } from 'node:events';
 import { spawn as mockedSpawn } from 'node:child_process';
-import { run, runBinary, runExecutor, RunnerTransportError, isRunnerTransportError } from '../src/runner.js';
-import type { Spawner, GogExecutor } from '../src/runner.js';
+import { run, runBinary } from '../src/runner.js';
+import type { Spawner } 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
@@ -533,28 +533,23 @@ describe('run', () => {
   });
 
   // The suffix list was `_TOKEN|_SECRET|_API_KEY|_PRIVATE_KEY` — four spellings
-  // of "a key", none of which is a bare `_KEY`. Two credentials this repo hands
-  // its own process sit in exactly that gap: `MCP_BLOB_SIGNING_KEY` (mints the
-  // signed blob URLs a `deliver="url"` download is uploaded to) and
-  // `GOG_RUNNER_KEY` (the bearer for the Fly backend, and for `POST /upload`,
-  // which is arbitrary-gog-argv on that box). Neither is anything `gog` reads.
-  it('strips a bare *_KEY var — the host signing key and the runner bearer', async () => {
+  // of "a key", none of which is a bare `_KEY`. `MCP_BLOB_SIGNING_KEY` (mints the
+  // signed blob URLs a `deliver="url"` download is uploaded to) sat in exactly
+  // that gap, and it is nothing `gog` reads.
+  it('strips a bare *_KEY var — the host blob signing key', async () => {
     const spawner = makeSpawner(0, '{}');
     const snapshot = {
       MCP_BLOB_SIGNING_KEY: process.env.MCP_BLOB_SIGNING_KEY,
-      GOG_RUNNER_KEY: process.env.GOG_RUNNER_KEY,
       STRIPE_KEY: process.env.STRIPE_KEY,
       AWS_CREDENTIALS: process.env.AWS_CREDENTIALS,
     };
     process.env.MCP_BLOB_SIGNING_KEY = 'blob-signing-secret';
-    process.env.GOG_RUNNER_KEY = 'runner-bearer-secret';
     process.env.STRIPE_KEY = 'sk-live-secret';
     process.env.AWS_CREDENTIALS = '/path/to/creds';
     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.MCP_BLOB_SIGNING_KEY).toBeUndefined();
-      expect(envPassed.GOG_RUNNER_KEY).toBeUndefined();
       expect(envPassed.STRIPE_KEY).toBeUndefined();
       // `_CREDENTIALS`, generalising the one named GOOGLE_APPLICATION_CREDENTIALS.
       expect(envPassed.AWS_CREDENTIALS).toBeUndefined();
@@ -803,14 +798,6 @@ describe('run', () => {
     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(() => {
@@ -906,82 +893,8 @@ describe('run --readonly (gog 0.31)', () => {
   });
 });
 
-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]');
-    }
-  });
-
-  // run() re-wraps every thrown error to redact secrets from its message. That
-  // rewrap must not cost a RunnerTransportError its TYPE: the type is the only
-  // thing that tells diagnose() the failure was the connector's transport and
-  // not the caller's Google credential, and a bare Error puts it straight back
-  // to guessing from prose.
-  it('preserves a RunnerTransportError through the redacting rewrap', async () => {
-    const executor = vi.fn(async () => {
-      throw new RunnerTransportError('runner key mismatch; saw 1//0eLEAKED-REFRESH end', 'transport-auth', 401);
-    }) as unknown as GogExecutor;
-    const err = await runExecutor
-      .run({ executor }, () => run(['gmail', 'get', 'm1']))
-      .catch((e: unknown) => e);
-    expect(isRunnerTransportError(err)).toBe(true);
-    expect((err as RunnerTransportError).kind).toBe('transport-auth');
-    expect((err as RunnerTransportError).status).toBe(401);
-    // and it is still redacted
-    expect((err as Error).message).not.toContain('1//0eLEAKED-REFRESH');
-    expect((err as Error).message).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 () => {
+describe('run executor', () => {
+  it('uses the lazily-imported real spawn when no spawner is injected', async () => {
     vi.mocked(mockedSpawn).mockImplementation((() => makeProc(0, '{"real":true}')) as never);
     const result = await run(['sheets', 'get', 'id1', 'A1']);
     expect(result).toBe('{"real":true}');

package/tests/sdk-single-copy.test.ts

@@ -3,46 +3,20 @@ import { createRequire } from 'node:module';
 import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-// Guards the invariant that broke dependabot #220: the whole monorepo must
-// resolve ONE copy of @modelcontextprotocol/sdk.
-//
-// `McpServer` carries a `private _serverInfo`, so TypeScript compares it
-// NOMINALLY, not structurally. Two installed copies therefore become two
-// mutually-unassignable classes, and every `ToolRegistrar` in server.ts fails
-// with TS2322 — with no API change and no source change anywhere. #220 split
-// the tree exactly that way: `agents` (a root devDependency, the Worker
-// connector's McpAgent) exact-pins the SDK to 1.29.0 and so takes the hoisted
-// root slot that `@chrischall/mcp-utils` resolves its peer from, while the
-// workspaces asking for ^1.30.0 each nested their own copy.
-//
-// This asserts resolution identity rather than a version string: the failure is
-// "two copies", not "the wrong version", and pinning a version here would just
-// have to be edited on every future bump.
-describe('@modelcontextprotocol/sdk is installed exactly once', () => {
-  const here = createRequire(import.meta.url);
+// Keep the modular SDK v2 server on one physical copy: its McpServer class
+// carries private state, so duplicate copies produce nominal TypeScript failures
+// that look like API incompatibilities.
+const here = createRequire(import.meta.url);
 
-  // An exported subpath — the SDK's `exports` map does not expose package.json.
-  const SDK_SUBPATH = '@modelcontextprotocol/sdk/server/mcp.js';
+const resolveFrom = (specifier: string, target: string): string =>
+  realpathSync(createRequire(fileURLToPath(import.meta.resolve(specifier))).resolve(target));
 
-  // `import.meta.resolve`, not `require.resolve`, to reach the dependency's own
-  // entry: these packages are ESM-only, so their `exports` maps carry no
-  // `require` condition and CJS resolution of the bare specifier throws.
-  const resolveFrom = (specifier: string): string =>
-    realpathSync(
-      createRequire(fileURLToPath(import.meta.resolve(specifier))).resolve(SDK_SUBPATH),
-    );
+describe('the MCP server SDK is installed exactly once', () => {
+  const MODERN_SERVER = '@modelcontextprotocol/server';
 
-  it('resolves to the same file for this package and for @chrischall/mcp-utils', () => {
-    // mcp-utils declares the SDK as a peer and hands our registrars the
-    // McpServer it built, so its copy is the one they must be typed against.
-    expect(resolveFrom('@chrischall/mcp-utils')).toBe(
-      realpathSync(here.resolve(SDK_SUBPATH)),
+  it('keeps the SDK v2 server shared by this package and mcp-utils', () => {
+    expect(resolveFrom('@chrischall/mcp-utils', MODERN_SERVER)).toBe(
+      realpathSync(here.resolve(MODERN_SERVER)),
     );
   });
-
-  it('resolves to the same file for `agents`, which exact-pins the SDK', () => {
-    // The Worker connector builds its McpServer via McpAgent from `agents`.
-    // An exact pin there is what captured the root hoist slot in #220.
-    expect(resolveFrom('agents')).toBe(realpathSync(here.resolve(SDK_SUBPATH)));
-  });
 });

package/tests/tools/appscript.test.ts

@@ -56,7 +56,7 @@ describe('gog_appscript_pull', () => {
   // hosted connector. A caller who does not know that gets a "success" whose
   // files they cannot reach.
   it('says in its description where the directory resolves', async () => {
-    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+    const { McpServer } = await import('@modelcontextprotocol/server');
     const server = new McpServer({ name: 'test', version: '0.0.0' });
     const configs = new Map<string, { description?: string }>();
     vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {

package/tests/tools/auth-401-shapes.test.ts

@@ -9,9 +9,8 @@ import { diagnose } from '../../src/tools/utils.js';
  *
  *   Google API error (401 authError): Invalid Credentials
  *
- * That shape is hard-coded in connector-runtime.ts as /Google API error \(401\b/
- * and used as the fixture across auth-log and connector-runtime tests. Losing it
- * is strictly worse than the `row 401` false positive that motivated the change:
+ * That is the shape gog prints for a dead Google credential. Losing it is
+ * strictly worse than the `row 401` false positive that motivated the change:
  * a false positive sends someone on a pointless re-auth, but this leaves a REAL
  * dead credential with no hint at all.
  */

package/tests/tools/auth.test.ts

@@ -171,16 +171,17 @@ describe('gog_auth_add', () => {
 
 describe('gog_auth_health', () => {
   it('names itself as the only live measurement of the Google layer', async () => {
-    // DEFECT 1's wording half: the hosted connector's "connected" / "refreshed"
-    // is an OAuth refresh inside OAUTH_KV that contacts neither Fly nor Google.
-    // Nothing in this repo can change that word, so the tool that DOES measure
-    // has to say that it is the one that does.
+    // A hosted connector's "connected" / "refreshed" is the client's OAuth to
+    // the MCP host, which never contacts Google. Nothing in this repo can change
+    // that word, so the tool that DOES measure has to say that it is the one
+    // that does.
     const harness = await setupHandlers();
     const { tools } = await harness.client.listTools();
     const desc = tools.find((t) => t.name === 'gog_auth_health')!.description!;
 
     expect(desc).toMatch(/connected|refreshed/i);
     expect(desc).toMatch(/only|nothing else/i);
+    expect(desc).not.toMatch(/connector key|gog machine/i);
     await harness.close();
   });