gogcli-mcp 3.0.0 → 4.0.1

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/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 { describe, it, expect, vi, beforeEach, afterEach } 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();
@@ -593,6 +588,50 @@ describe('run', () => {
     }
   });
 
+  // gog formats naive dates in GOG_TIMEZONE, else the process's local zone; the
+  // wrapper re-attaches offsets assuming GOG_TIMEZONE, else DISPLAY_TZ. Unless
+  // gog is TOLD the zone the wrapper assumes, a UTC host shifts every date.
+  describe('pins gog to the zone the wrapper reads its naive dates in', () => {
+    const keys = ['GOG_TIMEZONE', 'DISPLAY_TZ'] as const;
+    let snapshot: Record<string, string | undefined>;
+    beforeEach(() => { snapshot = Object.fromEntries(keys.map((k) => [k, process.env[k]])); });
+    afterEach(() => {
+      for (const [k, v] of Object.entries(snapshot)) {
+        if (v === undefined) delete process.env[k];
+        else process.env[k] = v;
+      }
+    });
+    const zoneGogGets = async (): Promise<string | undefined> => {
+      const spawner = makeSpawner(0, '{}');
+      await run(['gmail', 'search', 'x'], { spawner });
+      return ((spawner as ReturnType<typeof vi.fn>).mock.calls[0][2].env as NodeJS.ProcessEnv).GOG_TIMEZONE;
+    };
+
+    it('defaults gog to America/New_York when neither zone is set', async () => {
+      delete process.env.GOG_TIMEZONE;
+      delete process.env.DISPLAY_TZ;
+      expect(await zoneGogGets()).toBe('America/New_York');
+    });
+
+    it('hands gog DISPLAY_TZ when GOG_TIMEZONE is unset', async () => {
+      delete process.env.GOG_TIMEZONE;
+      process.env.DISPLAY_TZ = 'America/Los_Angeles';
+      expect(await zoneGogGets()).toBe('America/Los_Angeles');
+    });
+
+    it('passes a valid GOG_TIMEZONE through unchanged', async () => {
+      process.env.GOG_TIMEZONE = 'Europe/London';
+      process.env.DISPLAY_TZ = 'America/Los_Angeles';
+      expect(await zoneGogGets()).toBe('Europe/London');
+    });
+
+    it('replaces an invalid GOG_TIMEZONE with the zone the wrapper falls back to', async () => {
+      process.env.GOG_TIMEZONE = 'Not/AZone';
+      delete process.env.DISPLAY_TZ;
+      expect(await zoneGogGets()).toBe('America/New_York');
+    });
+  });
+
   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);
@@ -803,14 +842,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 +937,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,25 +3,17 @@ import { createRequire } from 'node:module';
 import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-// The Worker runtime still installs the legacy SDK through Cloudflare Agents,
-// while this project itself now uses the modular SDK v2 server.
-// Keep each lane on one physical copy: both server classes carry private state,
-// so duplicate copies produce nominal TypeScript failures that look like API
-// incompatibilities.
+// 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);
 
 const resolveFrom = (specifier: string, target: string): string =>
   realpathSync(createRequire(fileURLToPath(import.meta.resolve(specifier))).resolve(target));
 
-describe('MCP SDK packages are each installed exactly once', () => {
-  const LEGACY_SERVER = '@modelcontextprotocol/sdk/server/mcp.js';
+describe('the MCP server SDK is installed exactly once', () => {
   const MODERN_SERVER = '@modelcontextprotocol/server';
 
-  it('keeps the retained legacy lane used by agents at the root', () => {
-    const root = realpathSync(here.resolve(LEGACY_SERVER));
-    expect(resolveFrom('agents', LEGACY_SERVER)).toBe(root);
-  });
-
   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)),

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();
   });
 

package/tests/tools/drive.test.ts

@@ -468,14 +468,22 @@ describe('gog_drive_read_bytes', () => {
     expect(res.resource.uri).toBe('gogdrive://f2/file');
   });
 
-  it('surfaces the connector-degradation error via diagnose', async () => {
+  it('surfaces a byte-fetch failure via diagnose', async () => {
     vi.mocked(runner.run)
       .mockResolvedValueOnce(JSON.stringify({ file: { name: 'a.pdf', mimeType: 'application/pdf' } }))
       .mockResolvedValueOnce('user@x.com'); // diagnose -> auth list
-    vi.mocked(runner.runBinary).mockRejectedValueOnce(new Error('Raw byte retrieval is not available over the hosted connector'));
+    vi.mocked(runner.runBinary).mockRejectedValueOnce(new Error('gog exited with code 1'));
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_drive_read_bytes', { fileId: 'f1' });
     expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('not available over the hosted connector');
+    expect(result.content[0].text).toContain('gog exited with code 1');
+  });
+
+  it('no longer claims the hosted transport cannot carry bytes', async () => {
+    const harness = await setupHandlers();
+    const { tools } = await harness.client.listTools();
+    const desc = tools.find((t) => t.name === 'gog_drive_read_bytes')!.description!;
+    expect(desc).not.toMatch(/text-only|hosted connector/i);
+    await harness.close();
   });
 });

package/tests/tools/gmail.test.ts

@@ -304,8 +304,8 @@ describe('gog_gmail_send', () => {
 
   // ==========================================================================
   // INLINE ATTACHMENT BYTES — for callers with no filesystem in common with gog
-  // (the hosted connector, any GOG_RUNNER_URL backend). The bytes ride with the
-  // call and the executor materializes them beside gog.
+  // (a hosted deployment such as mcp-host). The bytes ride with the call and
+  // the runner materializes them beside gog.
   // ==========================================================================
   it('turns attachInline bytes into repeatable --attach file args', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');

package/tests/tools/utils.test.ts

@@ -1,13 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as runner from '../../src/runner.js';
 import { runOrDiagnose, pushPaginationFlags, formatAccountList, formatAuthHealth } from '../../src/tools/utils.js';
-import { RunnerTransportError } from '../../src/connector-runtime.js';
 
-// PARTIAL mock: only `run` is stubbed. A full automock would also replace
-// `RunnerTransportError` and `isRunnerTransportError`, and diagnose()'s whole
-// point is that it classifies the REAL class structurally — an automocked
-// brand check answers undefined for everything and the tests below would pass
-// while proving nothing.
+// PARTIAL mock: only `run` is stubbed; everything else stays real.
 vi.mock('../../src/runner.js', async (importOriginal) => ({
   ...(await importOriginal<typeof runner>()),
   run: vi.fn(),
@@ -605,47 +600,3 @@ describe('formatAuthHealth', () => {
     expect(formatAuthHealth('{"foo":1}', NOW)).toBe('{"foo":1}');
   });
 });
-
-// The connector's own transport failing is NOT the Google credential failing.
-// diagnose() must recognise that structurally, from the error's type, because
-// the runner's prose ("unauthorized") is indistinguishable from Google's.
-describe('diagnose: runner-authored transport failures', () => {
-  it('blames the runner key, not the Google account, for a transport-auth failure', async () => {
-    vi.mocked(runner.run)
-      .mockRejectedValueOnce(
-        new RunnerTransportError('gog-runner rejected the bearer token; GOG_RUNNER_KEY vs RUNNER_KEY', 'transport-auth', 401),
-      )
-      .mockResolvedValueOnce('user@gmail.com');
-    const result = await runOrDiagnose(['sheets', 'get', 'A1'], {});
-    const text = result.content[0].text as string;
-    expect(text).not.toContain('gog_auth_add');
-    expect(text).not.toMatch(/re-authorize the account/i);
-    expect(text).toContain('GOG_RUNNER_KEY');
-    expect(text).toContain('RUNNER_KEY');
-  });
-
-  it('lets the TYPE beat the prose: runner words that read like Google words get no re-auth hint', async () => {
-    // The regression this whole change exists to prevent. A runner-authored
-    // failure whose text happens to contain every Google auth signal must still
-    // not produce Google auth advice — the request never reached Google.
-    vi.mocked(runner.run)
-      .mockRejectedValueOnce(
-        new RunnerTransportError('unauthorized: 401 invalid_grant, token has been expired or revoked', 'transport-request', 400),
-      )
-      .mockResolvedValueOnce('user@gmail.com');
-    const result = await runOrDiagnose(['sheets', 'get', 'A1'], {});
-    const text = result.content[0].text as string;
-    expect(text).not.toContain('gog_auth_add');
-    expect(text).not.toContain('often transient');
-  });
-
-  it('advises a retry for a retryable transport failure', async () => {
-    vi.mocked(runner.run)
-      .mockRejectedValueOnce(new RunnerTransportError('gog-runner is restarting; retry this call.', 'transport-retryable', 503))
-      .mockResolvedValueOnce('user@gmail.com');
-    const result = await runOrDiagnose(['sheets', 'get', 'A1'], {});
-    const text = result.content[0].text as string;
-    expect(text).toContain('often transient');
-    expect(text).not.toContain('gog_auth_add');
-  });
-});