gogcli-mcp 2.30.0 → 4.0.0

package/src/tools/slides.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
 
@@ -6,13 +6,13 @@ export function registerSlidesTools(server: McpServer): void {
   server.registerTool('gog_slides_export', {
     description: 'Export a Google Slides presentation to a local file (pdf or pptx).',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       presentationId: z.string().describe('Presentation ID'),
       out: z.string().optional().describe('Output file path'),
       format: z.enum(['pdf', 'pptx']).optional().describe('Export format (default: pptx)'),
       overwrite: z.boolean().optional().describe('Overwrite the output file if it already exists (gog refuses otherwise)'),
       account: accountParam,
-    },
+    }),
   }, async ({ presentationId, out, format, overwrite, account }) => {
     const args = ['slides', 'export', presentationId];
     if (out) args.push(`--out=${out}`);
@@ -24,22 +24,22 @@ export function registerSlidesTools(server: McpServer): void {
   server.registerTool('gog_slides_info', {
     description: 'Get metadata for a Google Slides presentation (title, ID, slide count, etc.).',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       presentationId: z.string().describe('Presentation ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ presentationId, account }) => {
     return runOrDiagnose(['slides', 'info', presentationId], { account });
   });
 
   server.registerTool('gog_slides_create', {
     description: 'Create a new Google Slides presentation, optionally in a folder or copying from a template.',
-    inputSchema: {
+    inputSchema: z.object({
       title: z.string().describe('Presentation title'),
       parent: z.string().optional().describe('Destination folder ID'),
       template: z.string().optional().describe('Template presentation ID to copy from'),
       account: accountParam,
-    },
+    }),
   }, async ({ title, parent, template, account }) => {
     const args = ['slides', 'create', title];
     if (parent) args.push(`--parent=${parent}`);
@@ -49,12 +49,12 @@ export function registerSlidesTools(server: McpServer): void {
 
   server.registerTool('gog_slides_copy', {
     description: 'Copy a Google Slides presentation to a new presentation with the given title.',
-    inputSchema: {
+    inputSchema: z.object({
       presentationId: z.string().describe('Presentation ID to copy'),
       title: z.string().describe('Title for the new copy'),
       parent: z.string().optional().describe('Destination folder ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ presentationId, title, parent, account }) => {
     const args = ['slides', 'copy', presentationId, title];
     if (parent) args.push(`--parent=${parent}`);
@@ -64,10 +64,10 @@ export function registerSlidesTools(server: McpServer): void {
   server.registerTool('gog_slides_list_slides', {
     description: 'List slides in a Google Slides presentation.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       presentationId: z.string().describe('Presentation ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ presentationId, account }) => {
     return runOrDiagnose(['slides', 'list-slides', presentationId], { account });
   });
@@ -75,12 +75,12 @@ export function registerSlidesTools(server: McpServer): void {
   server.registerTool('gog_slides_read_slide', {
     description: 'Read the content of a slide (text, shapes, speaker notes). Set detail=true to also include normalized element geometry, styled text runs, paragraphs, table-cell content, and image source URLs.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       presentationId: z.string().describe('Presentation ID'),
       slideId: z.string().describe('Slide ID to read'),
       detail: z.boolean().optional().describe('Include normalized element geometry, styled text runs, paragraphs, table-cell content, and image source URLs'),
       account: accountParam,
-    },
+    }),
   }, async ({ presentationId, slideId, detail, account }) => {
     const args = ['slides', 'read-slide', presentationId, slideId];
     if (detail) args.push('--detail');

package/src/tools/tasks.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
 
@@ -6,9 +6,9 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_lists', {
     description: 'List all Google Task lists.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       account: accountParam,
-    },
+    }),
   }, async ({ account }) => {
     return runOrDiagnose(['tasks', 'lists', 'list'], { account });
   });
@@ -16,10 +16,10 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_list', {
     description: 'List tasks in a Google Task list.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       tasklistId: z.string().describe('Task list ID (use gog_tasks_lists to find IDs)'),
       account: accountParam,
-    },
+    }),
   }, async ({ tasklistId, account }) => {
     return runOrDiagnose(['tasks', 'list', tasklistId], { account });
   });
@@ -27,11 +27,11 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_get', {
     description: 'Get a specific task by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       tasklistId: z.string().describe('Task list ID'),
       taskId: z.string().describe('Task ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ tasklistId, taskId, account }) => {
     return runOrDiagnose(['tasks', 'get', tasklistId, taskId], { account });
   });
@@ -39,13 +39,13 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_add', {
     description: 'Add a task to a Google Task list.',
     annotations: { destructiveHint: false },
-    inputSchema: {
+    inputSchema: z.object({
       tasklistId: z.string().describe('Task list ID'),
       title: z.string().describe('Task title'),
       notes: z.string().optional().describe('Task notes/description'),
       due: z.string().optional().describe('Due date (YYYY-MM-DD or RFC3339)'),
       account: accountParam,
-    },
+    }),
   }, async ({ tasklistId, title, notes, due, account }) => {
     const args = ['tasks', 'add', tasklistId, `--title=${title}`];
     if (notes) args.push(`--notes=${notes}`);
@@ -56,11 +56,11 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_done', {
     description: 'Mark a task as completed.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       tasklistId: z.string().describe('Task list ID'),
       taskId: z.string().describe('Task ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ tasklistId, taskId, account }) => {
     return runOrDiagnose(['tasks', 'done', tasklistId, taskId], { account });
   });
@@ -68,11 +68,11 @@ export function registerTasksTools(server: McpServer): void {
   server.registerTool('gog_tasks_delete', {
     description: 'Delete a task.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       tasklistId: z.string().describe('Task list ID'),
       taskId: z.string().describe('Task ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ tasklistId, taskId, account }) => {
     // gog gates this delete behind a confirmation; the runner injects
     // --no-input, so without --force it refuses at runtime.

package/src/tools/utils.ts

@@ -1,9 +1,8 @@
 import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { McpServer, CallToolResult } from '@modelcontextprotocol/server';
 import { errorResult, rawTextResult, minifiedResult, stripMediaUrls } from '@chrischall/mcp-utils';
-import { run, isRunnerTransportError } from '../runner.js';
-import type { GogArg, RunnerFailureKind } from '../runner.js';
+import { run } from '../runner.js';
+import type { GogArg } from '../runner.js';
 import { normalizeTimestamps } from '../timestamps.js';
 import { stripConsumedPageToken } from '../pagination.js';
 
@@ -16,23 +15,20 @@ import { stripConsumedPageToken } from '../pagination.js';
 // "\n" cannot round-trip byte-for-byte through the file path. Second, the file
 // path costs a temp dir, a write, and a delete per call.
 //
-// The value matches the per-arg byte limit the Fly runner enforced BEFORE large
-// payloads could leave argv (the old MAX_ARG_LEN, 4096). That is deliberate:
-// every body that used to round-trip inline byte-for-byte still does, so this
-// change adds no trailing-newline regression for any body that already worked —
-// only bodies that previously exceeded the cap and hard-failed ("each arg must
-// be at most 4096 chars") now take the file path and its newline trim. The
-// runner's plain-arg cap is now 64 KiB, so a 4096-byte inline value is nowhere
-// near being rejected.
+// The value is the historical per-arg cap (4096) that applied BEFORE large
+// payloads could leave argv. That is deliberate: every body that used to
+// round-trip inline byte-for-byte still does, so there is no trailing-newline
+// regression for any body that already worked — only bodies that previously
+// exceeded the cap and hard-failed now take the file path and its newline trim.
 export const PAYLOAD_INLINE_MAX = 4096;
 
 // The ONE place the inline-vs-file decision is made. Every tool that has a
 // gog `--x` / `--x-file` flag pair routes its value through here so the
 // threshold cannot drift between tools.
 //
-// Measures BYTES, not characters: the Fly runner's cap and the Linux kernel's
-// MAX_ARG_STRLEN are both byte-based, so a multibyte-heavy body (CJK, emoji)
-// would slip past a `.length` check at up to 4x its real argv cost.
+// Measures BYTES, not characters: the Linux kernel's MAX_ARG_STRLEN is
+// byte-based, so a multibyte-heavy body (CJK, emoji) would slip past a
+// `.length` check at up to 4x its real argv cost.
 export function payloadArg(
   inlineFlag: string,
   fileFlag: string,
@@ -149,7 +145,7 @@ export function registerRunTool(
   server.registerTool(`gog_${service}_run`, {
     description,
     annotations: { destructiveHint: true },
-    inputSchema,
+    inputSchema: z.object(inputSchema),
   }, async (rawArgs) => {
     const { subcommand, args, account } = rawArgs as { subcommand: string; args: string[]; account?: string };
     return runOrDiagnose([service, subcommand, ...args], { account });
@@ -237,31 +233,6 @@ const GRID_LIMIT_HINT =
   '\n\nThe target range is outside the sheet\'s current grid. Add the missing rows or columns ' +
   'first with gog_sheets_insert (dimension: rows or cols), then retry the write.';
 
-// The hint for each RUNNER-authored failure kind (see RunnerTransportError in
-// runner.ts). These are chosen by the error's TYPE, never by reading its text.
-//
-// transport-auth is the one that motivated all of this. The runner answers a
-// bad bearer with the single word "unauthorized"; read as prose that is
-// indistinguishable from Google rejecting a credential, and the caller was
-// being told all session to re-authorize an account that had never been asked
-// for anything. So this hint names the real cause and says outright that
-// re-authorizing cannot help. It deliberately does NOT contain the literal
-// `gog_auth_add`, which is the token the rest of the auth guidance keys on.
-const RUNNER_TRANSPORT_AUTH_HINT =
-  '\n\nThis is the CONNECTOR\'s own transport auth failing, not your Google sign-in. The gog-runner ' +
-  'backend rejected the bearer token this server sent, so the request never reached gog and no Google ' +
-  'credential was checked — the Google account is not the problem and re-authorizing it cannot fix this. ' +
-  'An operator must make the Worker secret GOG_RUNNER_KEY equal RUNNER_KEY on the Fly app ' +
-  '(wrangler secret put GOG_RUNNER_KEY / fly secrets set RUNNER_KEY), then retry.';
-
-const RUNNER_TRANSPORT_HINTS: Record<RunnerFailureKind, string> = {
-  'transport-auth': RUNNER_TRANSPORT_AUTH_HINT,
-  // The request itself was malformed, so the runner will refuse it identically
-  // every time. Nothing to advise beyond the message the runner already gave.
-  'transport-request': '',
-  'transport-retryable': TRANSIENT_HINT,
-};
-
 // Reduce `gog auth list --json` output to just the configured email addresses.
 // The raw JSON also carries OAuth scopes, the Google subject id, and creation
 // timestamps — none of which belong in an error surfaced to the model, and
@@ -292,21 +263,6 @@ export function formatAccountList(raw: string): string {
 export async function diagnose(err: unknown): Promise<CallToolResult> {
   const errText = errorText(err);
 
-  // STRUCTURE BEFORE PROSE. A RunnerTransportError is this connector's own
-  // transport failing — its bearer, its request validation, its drain. Nothing
-  // was shown to Google, so none of the patterns below may be consulted for it:
-  // they exist to read gog's/Google's words, and the runner's words are not
-  // those. Read as prose, the runner's `unauthorized` matched
-  // DEFINITE_AUTH_PATTERN and produced AUTH_HINT — a human being told to
-  // re-authorize a healthy account over what was really a key mismatch.
-  //
-  // This short-circuits the ladder rather than joining it, so it is not a new
-  // rung in the precedence order documented below; that order still governs
-  // every error that genuinely came from gog.
-  const transportHint = isRunnerTransportError(err)
-    ? RUNNER_TRANSPORT_HINTS[err.kind]
-    : undefined;
-
   const isInvalidGrant = INVALID_GRANT_PATTERN.test(errText);
 
   // Precedence, and the reason for it. Reporting needs-auth is EXPENSIVE to be
@@ -322,10 +278,7 @@ export async function diagnose(err: unknown): Promise<CallToolResult> {
   const isTransientError = !DEFINITE_AUTH_PATTERN.test(errText) && TRANSIENT_ERROR_PATTERN.test(errText);
   const isAuthError = !isTransientError && AUTH_ERROR_PATTERN.test(errText);
   const isGridLimitError = GRID_LIMIT_ERROR_PATTERN.test(errText);
-  // `??`, not `||`: 'transport-request' maps to the empty string on purpose —
-  // "this failure is ours and there is nothing to advise" — and `||` would fall
-  // through to the prose ladder for exactly the errors that must never reach it.
-  const hint = transportHint ?? (isInvalidGrant
+  const hint = isInvalidGrant
     ? INVALID_GRANT_HINT
     : isAuthError
       ? AUTH_HINT
@@ -333,7 +286,7 @@ export async function diagnose(err: unknown): Promise<CallToolResult> {
         ? TRANSIENT_HINT
         : isGridLimitError
           ? GRID_LIMIT_HINT
-          : '');
+          : '';
   try {
     const accounts = formatAccountList(await run(['auth', 'list']));
     return errorResult(`${errText}\n\nConfigured accounts:\n${accounts || '(none)'}${hint}`);

package/tests/attachments.test.ts

@@ -125,9 +125,8 @@ describe('inlineAttachmentArgs', () => {
   // The budget belongs to the REQUEST, not to the attachments. `payloadArg`
   // turns any body over 4 KiB into a GogFileArg that rides in the same JSON
   // body at ~1:1, so a near-max attachment set plus a multi-MiB body overruns
-  // the runner even though each input is inside its own documented limit. That
-  // is the same invisible-transport-rejection failure the ceiling exists to
-  // prevent, so the sibling args are measured rather than assumed small.
+  // the budget even though each input is inside its own documented limit, so
+  // the sibling args are measured rather than assumed small.
   it('counts the message body against the same budget as the attachments', () => {
     // Three files just under the 8 MiB per-file cap, summing to just under the
     // per-message total — i.e. every input inside its own documented limit.
@@ -176,20 +175,18 @@ describe('inlineAttachmentArgs', () => {
 
   // THE INVARIANT behind the per-message ceiling, asserted rather than trusted.
   //
-  // connector-runtime sends every payload base64-encoded inside ONE JSON body,
-  // and the Fly runner caps that body at MAX_BODY_BYTES. Base64 inflates by 4/3,
-  // so a ceiling expressed in decoded bytes has to be derived from the wire cap
-  // or it documents a size that gets rejected as "request body too large" — a
-  // transport rejection from a layer the caller cannot see, which is the exact
-  // failure the tool-layer check exists to prevent. A 25 MiB total encoded to
-  // 34,952,536 chars against a 33,554,432 cap, so the limit was unreachable.
-  it('keeps a full message under the Fly runner request-body cap once base64-inflated', () => {
-    const RUNNER_MAX_BODY_BYTES = 32 * 1024 * 1024; // fly-gog-runner/server.mjs
+  // Every payload rides base64-encoded inside ONE JSON body, capped at a 32 MiB
+  // request budget. Base64 inflates by 4/3, so a ceiling expressed in decoded
+  // bytes has to be derived from the wire cap or it documents a size that cannot
+  // actually be sent. A 25 MiB total encoded to 34,952,536 chars against a
+  // 33,554,432 cap, so the limit was unreachable.
+  it('keeps a full message under the 32 MiB request budget once base64-inflated', () => {
+    const REQUEST_MAX_BODY_BYTES = 32 * 1024 * 1024;
     const encodedLength = (decoded: number): number => 4 * Math.ceil(decoded / 3);
 
     // The payload budget must leave the JSON structure room inside the cap…
-    expect(MAX_REQUEST_PAYLOAD_WIRE_BYTES).toBeLessThan(RUNNER_MAX_BODY_BYTES);
-    expect(RUNNER_MAX_BODY_BYTES - MAX_REQUEST_PAYLOAD_WIRE_BYTES).toBeGreaterThanOrEqual(128 * 1024);
+    expect(MAX_REQUEST_PAYLOAD_WIRE_BYTES).toBeLessThan(REQUEST_MAX_BODY_BYTES);
+    expect(REQUEST_MAX_BODY_BYTES - MAX_REQUEST_PAYLOAD_WIRE_BYTES).toBeGreaterThanOrEqual(128 * 1024);
     // …and a full attachment set must fit inside that budget once inflated.
     expect(encodedLength(MAX_INLINE_ATTACHMENT_TOTAL_BYTES)).toBeLessThanOrEqual(MAX_REQUEST_PAYLOAD_WIRE_BYTES);
     // The advertised number must itself be sendable — floor, not round.