gogcli-mcp 2.28.0 → 2.29.1

package/tests/tools/drive.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { registerDriveTools } from '../../src/tools/drive.js';
+import { registerDriveTools, DRIVE_LS_COMPACT_FIELDS } from '../../src/tools/drive.js';
 import * as runner from '../../src/runner.js';
 import { createTestHarness } from '@chrischall/mcp-utils/test';
 
@@ -7,6 +7,13 @@ vi.mock('../../src/runner.js');
 
 const setupHandlers = () => createTestHarness(registerDriveTools);
 
+// gog_drive_ls answers in the compact rung by default, so every call carries
+// the mask. These keep the flag-mapping tests below about flag mapping while
+// still asserting the shipped default rather than a view they opted out of.
+const lsArgs = (...extra: string[]) =>
+  ['drive', 'ls', ...extra, `--fields=${DRIVE_LS_COMPACT_FIELDS}`];
+const lsOpts = { account: undefined, fieldsMask: DRIVE_LS_COMPACT_FIELDS };
+
 beforeEach(() => vi.clearAllMocks());
 
 describe('gog_drive_ls', () => {
@@ -14,14 +21,48 @@ describe('gog_drive_ls', () => {
     vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', {});
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs(), lsOpts);
+  });
+
+  // Efficiency is not something a caller should have to ask for: the cheap rung
+  // is the default. Measured at 48% smaller on a 25-row listing.
+  it('defaults to the compact view, applying the field mask', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_ls', {});
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'ls', `--fields=${DRIVE_LS_COMPACT_FIELDS}`],
+      lsOpts,
+    );
+  });
+
+  it('sends no mask for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_ls', { view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined, fieldsMask: undefined });
+  });
+
+  // THE BUG THIS ALMOST SHIPPED: a Google field mask drops nextPageToken from
+  // the envelope, so a compact read returns page one with an EMPTY cursor and
+  // reads as "no more results" — silent truncation, verified live against gog
+  // 0.39.0. Naming the paging field in the mask is what brings it back.
+  it('names the paging field in the mask', () => {
+    expect(DRIVE_LS_COMPACT_FIELDS).toMatch(/^nextPageToken,/);
+  });
+
+  it('rejects a view rung this tool does not honour', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_drive_ls', { view: 'raw' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
   });
 
   it('passes folderId as --parent flag', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { folderId: 'folder1' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls', '--parent=folder1'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs('--parent=folder1'), lsOpts);
   });
 
   it('supports max, page, query, and allDrives flags', async () => {
@@ -34,8 +75,8 @@ describe('gog_drive_ls', () => {
       query: "name contains 'x'",
     });
     expect(runner.run).toHaveBeenCalledWith(
-      ['drive', 'ls', '--parent=folder1', '--max=50', '--page=tok', "--query=name contains 'x'"],
-      { account: undefined },
+      lsArgs('--parent=folder1', '--max=50', '--page=tok', "--query=name contains 'x'"),
+      lsOpts,
     );
   });
 
@@ -43,14 +84,14 @@ describe('gog_drive_ls', () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { allDrives: false });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls', '--no-all-drives'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs('--no-all-drives'), lsOpts);
   });
 
   it('omits all-drives flag when allDrives is true (default)', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { allDrives: true });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs(), lsOpts);
   });
 
   it('returns error text on failure', async () => {
@@ -62,11 +103,27 @@ describe('gog_drive_ls', () => {
 });
 
 describe('gog_drive_search', () => {
-  it('calls run with query', async () => {
+  // drive search accepts NO field mask — `gog schema --json` lists only nine
+  // commands that do, and this is not one — so the local media strip is the
+  // only projection available to it. Measured 27.8% end to end.
+  it('calls run with query, defaulting to the compact view', async () => {
     vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_search', { query: 'budget' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'search', 'budget'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'search', 'budget'],
+      { account: undefined, stripMedia: true },
+    );
+  });
+
+  it('keeps everything for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_search', { query: 'budget', view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'search', 'budget'],
+      { account: undefined, stripMedia: false },
+    );
   });
 
   it('returns error text on failure', async () => {
@@ -78,13 +135,24 @@ describe('gog_drive_search', () => {
 });
 
 describe('gog_drive_get', () => {
-  it('calls run with fileId', async () => {
-    vi.mocked(runner.run).mockResolvedValue('{"id":"file1"}');
+  // Excluded from the --fields work because a mask saved only 7% there: its
+  // default field set is already narrow. The media strip saves 27.5% on the
+  // same payload end to end, which clears the bar a parameter has to clear.
+  it('calls run with fileId, defaulting to the compact view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_get', { fileId: 'f1' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'f1'], { account: undefined, stripMedia: true });
+  });
+
+  it('keeps everything for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
-    await harness.callTool('gog_drive_get', { fileId: 'file1' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'file1'], { account: undefined });
+    await harness.callTool('gog_drive_get', { fileId: 'f1', view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'f1'], { account: undefined, stripMedia: false });
   });
 
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Not found'));
     const harness = await setupHandlers();

package/tests/tools/utils.test.ts

@@ -123,6 +123,147 @@ describe('runOrDiagnose', () => {
     expect(parsed.internalDateDisplay).toBeDefined();
   });
 
+  // Formatting whitespace is roughly a fifth of a large gog response and
+  // carries no information: gog pretty-prints its --json output, and nothing
+  // downstream reads the indent. Measured at 18.6% of a 19 KB `drive ls`.
+  it('minifies gog\'s pretty-printed JSON on the normal path', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "a": 1,\n  "b": [\n    2,\n    3\n  ]\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"a":1,"b":[2,3]}');
+  });
+
+  // Only FORMATTING whitespace goes. Whitespace inside a value is content —
+  // the blank line between paragraphs of a mail body — and JSON.stringify
+  // leaves every byte of it alone. A regex over the serialised text would
+  // corrupt exactly the payloads this is meant to shrink.
+  it('preserves whitespace INSIDE string values', async () => {
+    const body = 'Hi,\n\n  indented quote\n\nthanks';
+    vi.mocked(runner.run).mockResolvedValue(JSON.stringify({ body }, null, 2));
+    const result = await runOrDiagnose(['gmail', 'get'], {});
+    expect(JSON.parse(result.content[0].text as string).body).toBe(body);
+  });
+
+  // ofw-mcp emits paging state before its data array so a truncated read still
+  // sees it; the same reasoning applies to gog's nextPageToken. JSON.stringify
+  // preserves insertion order, so minifying must not reorder anything.
+  it('preserves key order', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "nextPageToken": "t",\n  "files": []\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"nextPageToken":"t","files":[]}');
+  });
+
+  // gog does not always answer in JSON — `gog auth list` is plain text, and an
+  // empty body is legal. Minification must pass anything unparseable through
+  // untouched rather than mangling it or throwing.
+  it('passes non-JSON output through untouched', async () => {
+    for (const text of ['user@gmail.com\nother@gmail.com', '', '   ', 'not json {']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['auth', 'list'], {});
+      expect(result.content[0].text).toBe(text);
+    }
+  });
+
+  // Brace-prefixed but unparseable — a truncated response from a killed gog, or
+  // a JSON prelude followed by garbage. It passes the `^[[{]` guard and then
+  // fails JSON.parse, and the only safe answer is the original bytes: a caller
+  // debugging a malformed payload needs to see what actually arrived.
+  //
+  // This path IS reachable through other suites today (gog_docs_structure feeds
+  // exactly this shape), but incidental coverage is not the same as a pinned
+  // behaviour — change that unrelated fixture and this branch goes dark, and
+  // the failure surfaces on whatever PR touched the fixture.
+  it('passes brace-prefixed but unparseable output through untouched', async () => {
+    for (const text of ['{"truncated": ', '[{"a":1},', '{not: json}']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['drive', 'ls'], {});
+      expect(result.content[0].text).toBe(text);
+      expect(result.isError).toBeUndefined();
+    }
+  });
+
+  // The lossless dumps are the rung a person reaches for when a payload is not
+  // what they expected, and indentation is most of what makes an unfamiliar
+  // shape legible — the same asymmetry mcp-utils' viewResult applies to `raw`.
+  it('does NOT minify a lossless response', async () => {
+    const raw = '{\n  "id": "m1"\n}';
+    vi.mocked(runner.run).mockResolvedValue(raw);
+    const result = await runOrDiagnose(['gmail', 'raw', 'm1'], { lossless: true });
+    expect(result.content[0].text).toBe(raw);
+  });
+
+  // A Google field mask is applied UPSTREAM, inside the API, so a mask this
+  // wrapper gets wrong is a hard 400 rather than a thin record. That makes the
+  // fallback the thing that keeps compact-by-default survivable: the same role
+  // mcp-utils' projectOrRaw plays for a projection done locally.
+  it('applies a compact field mask when one is given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'nextPageToken,files(id)' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'ls', '--fields=nextPageToken,files(id)'],
+      expect.objectContaining({ fieldsMask: 'nextPageToken,files(id)' }),
+    );
+  });
+
+  it('retries UNPROJECTED when Google rejects the mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Google API error (400 invalidParameter): Invalid field selection id'))
+      .mockResolvedValueOnce('{"files":[{"id":"f1"}]}');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(bogus)' });
+    expect(runner.run).toHaveBeenNthCalledWith(1, ['drive', 'ls', '--fields=files(bogus)'], expect.anything());
+    expect(runner.run).toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+    // The caller gets the whole payload, not an error: a projection that trips
+    // returns everything rather than taking the tool call down.
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toBe('{"files":[{"id":"f1"}]}');
+  });
+
+  // The fallback must not swallow real failures — a missing file is not a bad
+  // mask, and retrying it would just spend a second call to fail identically.
+  it('does NOT retry an error that is not a rejected mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('File not found'))
+      .mockResolvedValueOnce('user@gmail.com');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(id)' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+  });
+
+  // The second compact mechanism. `--fields` is a projection Google performs;
+  // this one is performed here, for the tools whose gog subcommand accepts no
+  // mask at all. Both surface through the same `view` vocabulary.
+  it('strips media keys when asked, and minifies the result', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      '{\n  "id": "f1",\n  "thumbnailLink": "https://lh3.googleusercontent.com/x=s220",\n  "webViewLink": "https://docs.google.com/d/f1"\n}',
+    );
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], { stripMedia: true });
+    expect(result.content[0].text).toBe('{"id":"f1","webViewLink":"https://docs.google.com/d/f1"}');
+  });
+
+  // webViewLink is the one URL a caller acts on and it sits in the same object
+  // as thumbnailLink. Stripping it would empty the response of the useful half.
+  it('keeps webViewLink and hasThumbnail while stripping the thumbnail', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      JSON.stringify({ files: [{ id: 'f1', hasThumbnail: false, thumbnailLink: 'https://x/y=s220', webViewLink: 'https://docs/f1' }] }),
+    );
+    const result = await runOrDiagnose(['drive', 'search', 'q'], { stripMedia: true });
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.files[0]).toEqual({ id: 'f1', hasThumbnail: false, webViewLink: 'https://docs/f1' });
+  });
+
+  it('does not strip media unless asked', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"thumbnailLink":"https://x/y=s220"}');
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], {});
+    expect(result.content[0].text).toBe('{"thumbnailLink":"https://x/y=s220"}');
+  });
+
+  // Non-JSON must survive the strip path exactly as it survives minification —
+  // the guard is shared, so a regression here would be silent.
+  it('passes non-JSON through untouched even when stripping is on', async () => {
+    vi.mocked(runner.run).mockResolvedValue('user@gmail.com');
+    const result = await runOrDiagnose(['auth', 'list'], { stripMedia: true });
+    expect(result.content[0].text).toBe('user@gmail.com');
+  });
+
   it('appends auth list on non-auth failure', async () => {
     vi.mocked(runner.run)
       .mockRejectedValueOnce(new Error('Doc not found'))

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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { createRequire } from 'node:module';
+import { realpathSync } from 'node:fs';
+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
+// `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
+// patch-level dependency.
+//
+// Read the resolved paths in such an error, not the signature.
+//
+// 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('zod is installed exactly once', () => {
+  const here = createRequire(import.meta.url);
+
+  // `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('zod'));
+
+  it('resolves to the same file for this package and for @chrischall/mcp-utils', () => {
+    // mcp-utils declares zod as a peer, and its `accountParam` / `viewParam` /
+    // `paginationParams` helpers build the very schemas our registrars pass to
+    // `registerTool`, so its copy is the one they must be typed against.
+    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', () => {
+    // `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(
+      realpathSync(here.resolve('zod')),
+    );
+  });
+});