gogcli-mcp 4.1.0 → 4.2.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
-    "version": "4.1.0"
+    "version": "4.2.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli",
       "source": "./",
       "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
-      "version": "4.1.0",
+      "version": "4.2.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp",
   "displayName": "gogcli",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -5,6 +5,32 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../../node_modules/@chrischall/mcp-utils/dist/cancel/index.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function withCallSignal(signal, fn) {
+  return signal ? storage.run({ signal }, fn) : fn();
+}
+function currentCallSignal() {
+  return storage.getStore()?.signal;
+}
+function killOnCancel(child, signal = "SIGTERM") {
+  const ambient = currentCallSignal();
+  if (!ambient)
+    return () => {
+    };
+  if (ambient.aborted) {
+    child.kill(signal);
+    return () => {
+    };
+  }
+  const onAbort = () => {
+    child.kill(signal);
+  };
+  ambient.addEventListener("abort", onAbort, { once: true });
+  return () => ambient.removeEventListener("abort", onAbort);
+}
+
 // ../../node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create = Object.create;
 var __defProp2 = Object.defineProperty;
@@ -34526,17 +34552,41 @@ Hint: ${err.hint}`);
   }
   throw err;
 }
+function callSignalFrom(args) {
+  const ctx = args.at(-1);
+  if (typeof ctx !== "object" || ctx === null)
+    return void 0;
+  const req = ctx.mcpReq;
+  if (typeof req !== "object" || req === null)
+    return void 0;
+  const signal = req.signal;
+  return signal instanceof AbortSignal ? signal : void 0;
+}
 function surfaceToolHints(server) {
   const register2 = server.registerTool.bind(server);
-  server.registerTool = (name, config2, cb) => register2(name, config2, (...args) => {
-    let result;
-    try {
-      result = cb(...args);
-    } catch (err) {
-      return hintResultOrRethrow(err);
-    }
-    return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
-  });
+  server.registerTool = (name, config2, cb) => register2(name, config2, (...args) => (
+    // THE CALLER'S CANCELLATION, made ambient for the whole handler
+    // (`cancel/index.ts`). The SDK delivers it and the fleet ignored it:
+    // measured against @modelcontextprotocol/server 2.0.0, a cancelled
+    // call aborts `ctx.mcpReq.signal` with the caller's reason and the
+    // handler runs to completion regardless — so the HTTP request stays
+    // in flight, the child keeps burning metered CPU, and the upstream
+    // keeps being hit for somebody who has gone. claude.ai sent 101
+    // cancellations in the week to 2026-09-20.
+    //
+    // Here because this is the one wrapper every tool already passes
+    // through: threading the signal by hand would mean editing several
+    // hundred handlers and missing exactly the ones nobody edits.
+    withCallSignal(callSignalFrom(args), () => {
+      let result;
+      try {
+        result = cb(...args);
+      } catch (err) {
+        return hintResultOrRethrow(err);
+      }
+      return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
+    })
+  ));
 }
 async function createMcpServer(opts) {
   const server = new McpServer({ name: opts.name, version: opts.version }, { supportedProtocolVersions: [...SERVER_PROTOCOL_VERSIONS] });
@@ -34971,8 +35021,15 @@ async function spawnGog(fullArgs, opts) {
     const stdoutChunks = [];
     const stderrChunks = [];
     let settled = false;
+    const cancelled = currentCallSignal();
+    const stopWatchingCancel = killOnCancel(child);
+    const stopWatching = () => {
+      clearTimeout(timer);
+      stopWatchingCancel();
+    };
     const timer = setTimeout(() => {
       settled = true;
+      stopWatchingCancel();
       child.kill();
       reject(new Error(`gog timed out after ${formatTimeout(effectiveTimeout)}`));
     }, effectiveTimeout);
@@ -34983,9 +35040,13 @@ async function spawnGog(fullArgs, opts) {
       stderrChunks.push(chunk);
     });
     child.on("close", (code) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
+      if (cancelled?.aborted) {
+        reject(cancelled.reason instanceof Error ? cancelled.reason : new Error("the caller cancelled this call"));
+        return;
+      }
       const stderr = Buffer.concat(stderrChunks).toString().trim();
       if (code === 0) {
         if (binary) {
@@ -35003,7 +35064,7 @@ async function spawnGog(fullArgs, opts) {
       }
     });
     child.on("error", (err) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
       if (err.code === "ENOENT") {
@@ -37521,7 +37582,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "4.1.0" : "0.0.0";
+var VERSION = true ? "4.2.0" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAppScriptTools,

package/dist/lib.js

@@ -19672,6 +19672,29 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
+// ../../node_modules/@chrischall/mcp-utils/dist/cancel/index.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function currentCallSignal() {
+  return storage.getStore()?.signal;
+}
+function killOnCancel(child, signal = "SIGTERM") {
+  const ambient = currentCallSignal();
+  if (!ambient)
+    return () => {
+    };
+  if (ambient.aborted) {
+    child.kill(signal);
+    return () => {
+    };
+  }
+  const onAbort = () => {
+    child.kill(signal);
+  };
+  ambient.addEventListener("abort", onAbort, { once: true });
+  return () => ambient.removeEventListener("abort", onAbort);
+}
+
 // ../../node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create = Object.create;
 var __defProp2 = Object.defineProperty;
@@ -33364,8 +33387,15 @@ async function spawnGog(fullArgs, opts) {
     const stdoutChunks = [];
     const stderrChunks = [];
     let settled = false;
+    const cancelled = currentCallSignal();
+    const stopWatchingCancel = killOnCancel(child);
+    const stopWatching = () => {
+      clearTimeout(timer);
+      stopWatchingCancel();
+    };
     const timer = setTimeout(() => {
       settled = true;
+      stopWatchingCancel();
       child.kill();
       reject(new Error(`gog timed out after ${formatTimeout(effectiveTimeout)}`));
     }, effectiveTimeout);
@@ -33376,9 +33406,13 @@ async function spawnGog(fullArgs, opts) {
       stderrChunks.push(chunk);
     });
     child.on("close", (code) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
+      if (cancelled?.aborted) {
+        reject(cancelled.reason instanceof Error ? cancelled.reason : new Error("the caller cancelled this call"));
+        return;
+      }
       const stderr = Buffer.concat(stderrChunks).toString().trim();
       if (code === 0) {
         if (binary) {
@@ -33396,7 +33430,7 @@ async function spawnGog(fullArgs, opts) {
       }
     });
     child.on("error", (err) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
       if (err.code === "ENOENT") {
@@ -35917,7 +35951,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "4.1.0" : "0.0.0";
+var VERSION = true ? "4.2.0" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAppScriptTools,

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp",
   "display_name": "gogcli",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "mcpName": "io.github.chrischall/gogcli-mcp",
   "description": "MCP server wrapping gogcli for Google service access",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -41,12 +41,12 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^1.0.0",
+    "@chrischall/mcp-utils": "^2.0.0",
     "@modelcontextprotocol/server": "^2.0.0",
     "zod": "^4.6.1"
   },
   "devDependencies": {
-    "@types/node": "^26.5.1",
+    "@types/node": "^26.6.1",
     "@vitest/coverage-v8": "^5.0.1",
     "esbuild": "^0.28.2",
     "typescript": "^7.0.2",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp"
   },
-  "version": "4.1.0",
+  "version": "4.2.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp",
-      "version": "4.1.0",
+      "version": "4.2.0",
       "transport": {
         "type": "stdio"
       },

package/src/runner.ts

@@ -1,6 +1,6 @@
 import type { ChildProcess } from 'node:child_process';
 import { delimiter, join } from 'node:path';
-import { parseBoolEnv, readEnvVar, redactSecrets as redactSharedSecrets } from '@chrischall/mcp-utils';
+import { currentCallSignal, killOnCancel, parseBoolEnv, readEnvVar, redactSecrets as redactSharedSecrets } from '@chrischall/mcp-utils';
 import { naiveSourceTimeZone } from './timestamps.js';
 
 export type Spawner = (
@@ -380,8 +380,26 @@ async function spawnGog(
     const stderrChunks: Buffer[] = [];
     let settled = false;
 
+    // THE CALLER GIVING UP KILLS THE CHILD (mcp-utils `cancel`). Until this,
+    // a cancelled tool call left a whole `gog` process running to the
+    // timeout below — still talking to Google, still charged to the CPU a
+    // hosted child is metered on, for somebody who has gone. Measured on the
+    // mcp-host fleet: claude.ai sent 101 cancellations in the week to
+    // 2026-09-20, and every one of them was ignored here.
+    //
+    // The signal is ambient rather than passed: `surfaceToolHints` puts it
+    // in scope for the whole handler, so this works for every tool in every
+    // package without one of them threading it through.
+    const cancelled = currentCallSignal();
+    const stopWatchingCancel = killOnCancel(child);
+    const stopWatching = (): void => {
+      clearTimeout(timer);
+      stopWatchingCancel();
+    };
+
     const timer = setTimeout(() => {
       settled = true;
+      stopWatchingCancel();
       child.kill();
       reject(new Error(`gog timed out after ${formatTimeout(effectiveTimeout)}`));
     }, effectiveTimeout);
@@ -390,9 +408,17 @@ async function spawnGog(
     child.stderr!.on('data', (chunk: Buffer) => { stderrChunks.push(chunk); });
 
     child.on('close', (code: number | null) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
+      // A child WE killed because the caller left exits with no code and no
+      // stderr, which the branch below would report as `gog exited with code
+      // null` — a sentence about gogcli for something gogcli did not do. The
+      // caller's own reason is the honest error.
+      if (cancelled?.aborted) {
+        reject(cancelled.reason instanceof Error ? cancelled.reason : new Error('the caller cancelled this call'));
+        return;
+      }
       const stderr = Buffer.concat(stderrChunks).toString().trim();
       if (code === 0) {
         // Binary mode: return the raw stdout bytes base64-encoded, never a utf8
@@ -413,7 +439,7 @@ async function spawnGog(
     });
 
     child.on('error', (err: Error) => {
-      clearTimeout(timer);
+      stopWatching();
       if (settled) return;
       settled = true;
       if ((err as NodeJS.ErrnoException).code === 'ENOENT') {

package/tests/runner.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { EventEmitter } from 'node:events';
 import { spawn as mockedSpawn } from 'node:child_process';
+import { withCallSignal } from '@chrischall/mcp-utils';
 import { run, runBinary } from '../src/runner.js';
 import type { Spawner } from '../src/runner.js';
 
@@ -949,3 +950,74 @@ describe('run executor', () => {
     );
   });
 });
+
+/**
+ * The caller giving up kills the `gog` child (mcp-utils `cancel`).
+ *
+ * Until this, a cancelled tool call left a whole process running to the
+ * runner's own timeout — still talking to Google, still charged to the CPU a
+ * hosted child is metered on, for somebody who has gone. Measured on the
+ * mcp-host fleet: claude.ai sent 101 cancellations in the week to
+ * 2026-09-20, and every one of them was ignored here.
+ */
+describe('cancellation', () => {
+  /** A child that never finishes on its own — only a kill ends it. */
+  function hangingProc(): ReturnType<Spawner> & { killed: unknown[] } {
+    const proc = new EventEmitter() as ReturnType<Spawner> & { killed: unknown[] };
+    const io = proc as unknown as { stdout: EventEmitter; stderr: EventEmitter };
+    io.stdout = new EventEmitter();
+    io.stderr = new EventEmitter();
+    proc.killed = [];
+    proc.kill = vi.fn((sig?: unknown) => {
+      proc.killed.push(sig);
+      // A killed child closes with no code and no stderr, which is exactly
+      // the shape the error path has to tell apart from a gog failure.
+      setTimeout(() => proc.emit('close', null), 0);
+      return true;
+    }) as unknown as ReturnType<Spawner>['kill'];
+    return proc;
+  }
+
+  it('kills the child and rejects with the caller’s own reason', async () => {
+    const proc = hangingProc();
+    const controller = new AbortController();
+    const reason = new Error('caller went away');
+
+    const call = withCallSignal(controller.signal, () =>
+      run(['sheets', 'get', 'id1', 'A1'], { spawner: (() => proc) as unknown as Spawner }),
+    );
+    controller.abort(reason);
+
+    // Not `gog exited with code null`, which is what the ordinary close path
+    // would have said — a sentence about gogcli for something gogcli did not
+    // do.
+    await expect(call).rejects.toThrow(reason);
+    expect(proc.killed, 'the gog child was left running').toEqual(['SIGTERM']);
+  });
+
+  it('names the cancellation when the reason is not an Error', async () => {
+    // `AbortController.abort()` takes ANY value — a string, a DOMException,
+    // undefined — so the reason is not guaranteed to be throwable. Rejecting
+    // with a raw string would surface as an error with no message at the
+    // tool boundary, which is the shape this whole change exists to avoid.
+    const proc = hangingProc();
+    const controller = new AbortController();
+
+    const call = withCallSignal(controller.signal, () =>
+      run(['sheets', 'get', 'id1', 'A1'], { spawner: (() => proc) as unknown as Spawner }),
+    );
+    controller.abort('the caller went away');
+
+    await expect(call).rejects.toThrow(/cancelled/i);
+    expect(proc.killed).toEqual(['SIGTERM']);
+  });
+
+  it('leaves an ordinary call alone, and stops listening when it finishes', async () => {
+    const controller = new AbortController();
+    const spawner = makeSpawner(0, '{"ok":true}');
+    await withCallSignal(controller.signal, () => run(['sheets', 'get', 'id1', 'A1'], { spawner }));
+    // Aborting AFTER the call settled must reach nothing: a listener that
+    // outlives its call is a leak per invocation.
+    expect(() => controller.abort(new Error('too late'))).not.toThrow();
+  });
+});