gogcli-mcp 2.30.0 → 4.0.0

package/tests/tools/chat.test.ts

@@ -38,7 +38,7 @@ describe('gog_chat_spaces_list', () => {
   // description a model reads — a source comment would not reach it. Every chat
   // tool carries the note, because any of them can be the first one called.
   it('warns in EVERY description that Chat is Workspace-only', 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/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

@@ -3,10 +3,14 @@ import { registerGmailTools } from '../../src/tools/gmail.js';
 import * as runner from '../../src/runner.js';
 import { PAYLOAD_INLINE_MAX } from '../../src/tools/utils.js';
 import { createTestHarness } from '@chrischall/mcp-utils/test';
+import type { ElicitRequest, ElicitResult } from '@modelcontextprotocol/server';
 
 vi.mock('../../src/runner.js');
 
-const setupHandlers = () => createTestHarness(registerGmailTools);
+const setupHandlers = (
+  elicitation: (request: ElicitRequest) => ElicitResult | Promise<ElicitResult> =
+    async () => ({ action: 'accept', content: { confirmed: true } }),
+) => createTestHarness(registerGmailTools, { elicitation });
 
 beforeEach(() => vi.clearAllMocks());
 
@@ -300,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('{}');
@@ -425,6 +429,88 @@ describe('gog_gmail_send', () => {
     const result = await harness.callTool('gog_gmail_send', { to: 'x', subject: 'y', body: 'z' });
     expect(result.content[0].text).toBe('Error: Send failed');
   });
+
+  // ==========================================================================
+  // THE CONFIRMATION GATE. Unlike reply/reply-all, send's recipients are
+  // explicit params, so its preview needs no extra gog call at all.
+  // ==========================================================================
+  describe('confirmation gate', () => {
+    it('elicits a recipient preview and sends only after the user accepts it', async () => {
+      vi.mocked(runner.run).mockResolvedValue('{}');
+      let request: ElicitRequest | undefined;
+      const harness = await setupHandlers(async (value) => {
+        request = value;
+        return { action: 'accept', content: { confirmed: true } };
+      });
+      const result = await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', cc: 'carol@example.com', subject: 'Hi', body: 'Hello',
+        replyToMessageId: 'm1', quote: true,
+      });
+      expect(request?.params.message).toContain('bob@example.com');
+      expect(request?.params.message).toContain('carol@example.com');
+      expect(request?.params.message).toContain('"threaded": true');
+      expect(request?.params.requestedSchema).toEqual(expect.objectContaining({ type: 'object' }));
+      expect(result.isError).not.toBe(true);
+      expect(runner.run).toHaveBeenCalledTimes(1);
+    });
+
+    it('sends nothing when the user declines the elicitation', async () => {
+      const harness = await setupHandlers(async () => ({ action: 'decline' }));
+      const result = await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', subject: 'Hi', body: 'Hello',
+      });
+      expect(runner.run).not.toHaveBeenCalled();
+      expect(JSON.parse(result.content[0].text as string)).toEqual(expect.objectContaining({
+        confirmed: false,
+        cancelled: true,
+        action: 'gmail.send',
+      }));
+    });
+
+    it('sends nothing when the user accepts but leaves confirmation false', async () => {
+      const harness = await setupHandlers(async () => ({ action: 'accept', content: { confirmed: false } }));
+      const result = await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', subject: 'Hi', body: 'Hello',
+      });
+      expect(runner.run).not.toHaveBeenCalled();
+      expect(JSON.parse(result.content[0].text as string).cancelled).toBe(true);
+    });
+
+    it('logs a gmail_dispatch event with the recipients after an accepted send', async () => {
+      vi.mocked(runner.run).mockResolvedValue('{}');
+      const writeSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+      const harness = await setupHandlers();
+      await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', subject: 'Hi', body: 'Hello',
+      });
+      const event = JSON.parse((writeSpy.mock.calls.at(-1)?.[0] as string).trim());
+      expect(event.event).toBe('gmail_dispatch');
+      expect(event.tool).toBe('gog_gmail_send');
+      expect(event.recipientCount).toBe(1);
+      writeSpy.mockRestore();
+    });
+
+    it('does not log when the accepted send fails', async () => {
+      vi.mocked(runner.run).mockRejectedValue(new Error('Send failed'));
+      const writeSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+      const harness = await setupHandlers();
+      await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', subject: 'Hi', body: 'Hello',
+      });
+      expect(writeSpy).not.toHaveBeenCalled();
+      writeSpy.mockRestore();
+    });
+
+    it('still validates attachments before either preview or send', async () => {
+      const harness = await setupHandlers();
+      const res = await harness.callTool('gog_gmail_send', {
+        to: 'bob@example.com', subject: 's', body: 'b',
+        attachInline: [{ filename: 'a.png', contentBase64: 'not!valid!base64!' }],
+      });
+      expect(res.isError).toBe(true);
+      expect(runner.run).not.toHaveBeenCalled();
+    });
+  });
 });
 
 describe('gog_gmail_run', () => {
@@ -630,7 +716,9 @@ describe('gog_gmail_reply — full flag set', () => {
   it('omits --no-quote and --signature when false', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', noQuote: false, signature: false });
+    await harness.callTool('gog_gmail_reply', {
+      messageId: 'm1', body: 'Hi', noQuote: false, signature: false,
+    });
     expect(runner.run).toHaveBeenCalledWith(
       ['gmail', 'reply', 'm1', '--body=Hi', '--auto-from-addressed-alias=false'],
       { account: undefined },
@@ -672,6 +760,150 @@ describe('gog_gmail_reply_all — full flag set', () => {
     );
   });
 });
+
+// ============================================================================
+// THE CONFIRMATION GATE. The first protocol round returns input_required and
+// the harness routes its embedded elicitation through the handler supplied to
+// setupHandlers. Declining lets these tests inspect the prompt while proving
+// the send subcommand was never reached.
+// ============================================================================
+describe.each([
+  ['gog_gmail_reply', 'reply' as const],
+  ['gog_gmail_reply_all', 'reply-all' as const],
+])('%s — confirmation gate', (tool, subcommand) => {
+  const METADATA = JSON.stringify({
+    headers: { from: 'Alice <alice@example.com>', to: 'me@example.com', cc: 'Carol <carol@law-firm.example>', subject: 'Contract terms' },
+  });
+
+  const promptedDetails = async (args: Record<string, unknown>, metadata = METADATA) => {
+    vi.mocked(runner.run).mockResolvedValue(METADATA);
+    if (metadata !== METADATA) vi.mocked(runner.run).mockResolvedValue(metadata);
+    let request: ElicitRequest | undefined;
+    const harness = await setupHandlers(async (value) => {
+      request = value;
+      return { action: 'decline' };
+    });
+    const result = await harness.callTool(tool, { messageId: 'm1', ...args });
+    return {
+      result,
+      request,
+      details: (JSON.parse(request?.params.message.split('\n').slice(1).join('\n') ?? '{}') as {
+        details?: Record<string, unknown>;
+      }).details ?? {},
+    };
+  };
+
+  it('elicits the resolved recipients and sends nothing when the user declines', async () => {
+    const { result, request, details } = await promptedDetails({ body: 'Sounds good' });
+    expect(runner.run).toHaveBeenCalledTimes(2);
+    expect(runner.run).toHaveBeenCalledWith(['gmail', 'get', 'm1', '--format=metadata'], { account: undefined });
+    expect(request?.params.requestedSchema).toEqual(expect.objectContaining({ type: 'object' }));
+    expect(JSON.parse(result.content[0].text as string)).toEqual(expect.objectContaining({
+      confirmed: false,
+      cancelled: true,
+      action: `gmail.${subcommand}`,
+    }));
+    if (subcommand === 'reply') {
+      expect(details.recipients).toEqual(['alice@example.com']);
+    } else {
+      expect(details.recipients).toEqual(['alice@example.com', 'me@example.com', 'carol@law-firm.example']);
+    }
+  });
+
+  it('sends nothing when the user accepts but leaves confirmation false', async () => {
+    vi.mocked(runner.run).mockResolvedValue(METADATA);
+    const harness = await setupHandlers(async () => ({ action: 'accept', content: { confirmed: false } }));
+    const result = await harness.callTool(tool, { messageId: 'm1', body: 'x' });
+    expect(runner.run).toHaveBeenCalledTimes(2);
+    expect(JSON.parse(result.content[0].text as string).cancelled).toBe(true);
+  });
+
+  it('falls back to "Re: <original subject>" in the prompt when no subject override is given', async () => {
+    const { details } = await promptedDetails({ body: 'x' });
+    expect(details.subject).toBe('Re: Contract terms');
+  });
+
+  it('prefers an explicit subject override in the prompt over the inherited one', async () => {
+    const { details } = await promptedDetails({ body: 'x', subject: 'Custom subject' });
+    expect(details.subject).toBe('Custom subject');
+  });
+
+  it('actually sends and logs the resolved recipients after the user accepts', async () => {
+    vi.mocked(runner.run)
+      .mockResolvedValueOnce(METADATA)
+      .mockResolvedValueOnce(METADATA)
+      .mockResolvedValueOnce('{"id":"sent1"}');
+    const writeSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    const harness = await setupHandlers();
+    const result = await harness.callTool(tool, { messageId: 'm1', body: 'Sounds good' });
+    expect(runner.run).toHaveBeenCalledTimes(3);
+    expect(runner.run).toHaveBeenNthCalledWith(1, ['gmail', 'get', 'm1', '--format=metadata'], { account: undefined });
+    expect(runner.run).toHaveBeenNthCalledWith(
+      3,
+      ['gmail', subcommand, 'm1', '--body=Sounds good', '--auto-from-addressed-alias=false'],
+      { account: undefined },
+    );
+    expect(result.content[0].text).toBe('{"id":"sent1"}');
+    const event = JSON.parse((writeSpy.mock.calls.at(-1)?.[0] as string).trim());
+    expect(event.event).toBe('gmail_dispatch');
+    expect(event.tool).toBe(tool);
+    expect(event.recipientCount).toBeGreaterThan(0);
+    writeSpy.mockRestore();
+  });
+
+  it('does not log when the accepted send itself fails', async () => {
+    vi.mocked(runner.run)
+      .mockResolvedValueOnce(METADATA)
+      .mockResolvedValueOnce(METADATA)
+      .mockRejectedValueOnce(new Error('quota exceeded'));
+    const writeSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    const harness = await setupHandlers();
+    const result = await harness.callTool(tool, { messageId: 'm1', body: 'x' });
+    expect(result.isError).toBe(true);
+    expect(writeSpy).not.toHaveBeenCalled();
+    writeSpy.mockRestore();
+  });
+
+  it('surfaces a bad messageId as a diagnosed error, without ever building a preview', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('message not found'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool(tool, { messageId: 'bad', body: 'x' });
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('message not found');
+  });
+
+  it('measures bodyLength from bodyHtml when no plain body is given', async () => {
+    const { details } = await promptedDetails({ bodyHtml: '<p>Hi</p>' });
+    expect(details.bodyLength).toBe('<p>Hi</p>'.length);
+  });
+
+  it('measures bodyLength as zero when neither body nor bodyHtml is given', async () => {
+    const { details } = await promptedDetails({});
+    expect(details.bodyLength).toBe(0);
+  });
+
+  it('ignores a non-string header value in the metadata response', async () => {
+    const { details } = await promptedDetails({ body: 'x' }, JSON.stringify({
+      headers: { from: 'alice@example.com', subject: 42 },
+    }));
+    expect(details.recipients).toEqual(['alice@example.com']);
+    expect(details.subject).toBeUndefined();
+  });
+
+  it('treats an unparseable metadata response as empty headers rather than crashing', async () => {
+    const { details } = await promptedDetails({ body: 'x' }, 'not json at all');
+    expect(details.recipients).toEqual([]);
+  });
+
+  it('applies to/cc/bcc adds and remove drops on top of the inherited recipients in the prompt', async () => {
+    const { details } = await promptedDetails({
+      body: 'x', to: ['dave@example.com'], remove: ['carol@law-firm.example'],
+    });
+    expect(details.recipients).not.toContain('carol@law-firm.example');
+    expect(details.recipients).toContain('dave@example.com');
+  });
+});
+
 describe('gog_gmail_reply body-vs-file conflicts', () => {
   it('rejects bodyHtml plus bodyHtmlFile before gog runs', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
@@ -699,7 +931,9 @@ describe('gog_gmail_reply body-vs-file conflicts', () => {
   it('passes bodyHtmlFile alone through as --body-html-file', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
-    await harness.callTool('gog_gmail_reply', { messageId: 'm1', body: 'Hi', bodyHtmlFile: '/tmp/b.html' });
+    await harness.callTool('gog_gmail_reply', {
+      messageId: 'm1', body: 'Hi', bodyHtmlFile: '/tmp/b.html',
+    });
     expect(runner.run).toHaveBeenCalledWith(
       ['gmail', 'reply', 'm1', '--body=Hi', '--body-html-file=/tmp/b.html', '--auto-from-addressed-alias=false'],
       { account: undefined },
@@ -729,17 +963,13 @@ describe('gog_gmail_reply body-vs-file conflicts', () => {
 // timeout. No file param may advertise it as usable.
 describe('reply file params never advertise stdin as usable', () => {
   it.each(['gog_gmail_reply', 'gog_gmail_reply_all'])('%s.bodyHtmlFile warns that stdin hangs', async (tool) => {
-    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
-    const server = new McpServer({ name: 'test', version: '0.0.0' });
-    const configs = new Map<string, Record<string, { description?: string }>>();
-    vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {
-      configs.set(name, (config as { inputSchema: Record<string, { description?: string }> }).inputSchema);
-      return undefined as never;
-    });
-    registerGmailTools(server);
-    const desc = configs.get(tool)?.bodyHtmlFile?.description ?? '';
+    const harness = await setupHandlers();
+    const listed = (await harness.client.listTools()).tools.find((candidate) => candidate.name === tool);
+    const properties = listed?.inputSchema.properties as Record<string, { description?: string }> | undefined;
+    const desc = properties?.bodyHtmlFile?.description ?? '';
     expect(desc).not.toBe('');
     expect(desc).not.toMatch(/(?:or|use)\s+"?-"?\s+(?:for|to read)/i);
     expect(desc).toMatch(/stdin/i);
+    expect(properties).not.toHaveProperty('confirmed');
   });
 });

package/tests/tools/sheets.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { registerSheetsTools } from '../../src/tools/sheets.js';
 import * as runner from '../../src/runner.js';
 import { createTestHarness } from '@chrischall/mcp-utils/test';

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

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

@@ -6,12 +6,12 @@ import { fileURLToPath } from 'node:url';
 // The zod counterpart of sdk-single-copy.test.ts, guarding the invariant that
 // broke dependabot #333: the whole monorepo must resolve ONE copy of zod.
 //
-// Same shape of failure, a different package. `@cloudflare/vitest-pool-workers`
-// (a root devDependency) declares zod as an **exact** pin, so it takes the
-// hoisted root slot that `@chrischall/mcp-utils` and the MCP SDK resolve their
-// zod peer from. The moment our workspaces ask for a newer zod than that pin,
-// each nests its own copy — and because a `ZodType` carries brand-bearing
-// internals, TypeScript compares the two NOMINALLY: every schema our tools hand
+// Same shape of failure, a different package. Any dependency that pins zod
+// can take the hoisted root slot that `@chrischall/mcp-utils` and the MCP SDK
+// resolve their zod peer from (#333: a since-removed devDependency's exact pin).
+// The moment our workspaces ask for a newer zod than that pin, each nests its
+// own copy — and because a `ZodType` carries brand-bearing internals,
+// TypeScript compares the two NOMINALLY: every schema our tools hand
 // `registerTool` fails with `TS2322: Type 'ZodString' is not assignable to type
 // 'AnySchema'`, with no API change and nothing to fix in the source. #333 split
 // the tree exactly that way and produced 11,024 type errors from a bump of one
@@ -38,18 +38,10 @@ describe('zod is installed exactly once', () => {
     expect(resolveFrom('@chrischall/mcp-utils')).toBe(realpathSync(here.resolve('zod')));
   });
 
-  it('resolves to the same file for the MCP SDK, which types every tool schema', () => {
+  it('resolves to the same file for the MCP server SDK, which types every tool schema', () => {
     // `registerTool` accepts the raw shape and infers the handler's argument
     // types from it; a second copy makes every one of those schemas foreign.
-    expect(resolveFrom('@modelcontextprotocol/sdk/server/mcp.js')).toBe(
-      realpathSync(here.resolve('zod')),
-    );
-  });
-
-  it('resolves to the same file for @cloudflare/vitest-pool-workers, which exact-pins zod', () => {
-    // The exact pin here is what captured the root hoist slot in #333, and it
-    // is why the root `overrides` block carries a zod entry.
-    expect(resolveFrom('@cloudflare/vitest-pool-workers')).toBe(
+    expect(resolveFrom('@modelcontextprotocol/server')).toBe(
       realpathSync(here.resolve('zod')),
     );
   });

package/tsconfig.json

@@ -5,8 +5,5 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  // src/worker.ts is the Cloudflare-Worker entry: it imports
-  // @chrischall/mcp-connector (which pulls the `agents` runtime + Cloudflare
-  // types) and is compiled by wrangler/esbuild, not by this stdio tsc build.
-  "exclude": ["node_modules", "dist", "src/worker.ts"]
+  "exclude": ["node_modules", "dist"]
 }

package/vitest.config.ts

@@ -1,11 +1,7 @@
-import { configDefaults, defineConfig } from 'vitest/config';
+import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    // `tests/worker.test.ts` only runs under the Workers runtime pool
-    // (root `vitest.workers.config.mts` / `npm run worker:test`), which provides
-    // the virtual `cloudflare:test` module it imports. The node pool must skip it.
-    exclude: [...configDefaults.exclude, 'tests/worker.test.ts'],
     // Neutralize the gog env vars for the whole suite.
     //
     // THE BUG THIS FIXES: the runner tests assert the exact argv `run()` builds,
@@ -28,15 +24,7 @@ export default defineConfig({
     coverage: {
       provider: 'v8',
       include: ['src/**/*.ts'],
-      exclude: [
-        'src/index.ts',
-        // src/worker.ts is the only Worker-path file that can't load under the
-        // node pool (it imports the `@chrischall/mcp-connector`/`agents` runtime);
-        // it's exercised by the Workers pool suite (`npm run worker:test`). Its
-        // testable helpers live in src/connector-runtime.ts, and src/connector-auth.ts
-        // is node-loadable — both are unit-tested here and stay in the 100% gate.
-        'src/worker.ts',
-      ],
+      exclude: ['src/index.ts'],
       thresholds: {
         lines: 100,
         functions: 100,