gogcli-mcp 2.0.11 → 2.2.0

package/server.json

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

package/src/tools/calendar.ts

@@ -39,7 +39,7 @@ export function registerCalendarTools(server: McpServer): void {
   });
 
   server.registerTool('gog_calendar_create', {
-    description: 'Create a calendar event.',
+    description: 'Create a calendar event. Set withZoom=true to attach a Zoom meeting (requires Zoom S2S OAuth setup via gog_zoom_auth_setup; the join URL + meeting ID + passcode are appended to the event description — Google rejects native conference card writes from non-Workspace-Marketplace OAuth clients).',
     annotations: { destructiveHint: false },
     inputSchema: {
       calendarId: z.string().describe('Calendar ID (use "primary" for the default calendar)'),
@@ -50,19 +50,21 @@ export function registerCalendarTools(server: McpServer): void {
       location: z.string().optional().describe('Event location'),
       attendees: z.string().optional().describe('Attendee emails, comma-separated'),
       allDay: z.boolean().optional().describe('All-day event (use date-only in from/to)'),
+      withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event (requires Zoom S2S OAuth setup)'),
       account: accountParam,
     },
-  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, account }) => {
+  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, withZoom, account }) => {
     const args = ['calendar', 'create', calendarId, `--summary=${summary}`, `--from=${from}`, `--to=${to}`];
     if (description) args.push(`--description=${description}`);
     if (location) args.push(`--location=${location}`);
     if (attendees) args.push(`--attendees=${attendees}`);
     if (allDay) args.push('--all-day');
+    if (withZoom) args.push('--with-zoom');
     return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_calendar_update', {
-    description: 'Update an existing calendar event.',
+    description: 'Update an existing calendar event. Zoom: withZoom adds a Zoom meeting, regenerateZoom replaces the existing one, removeZoom strips it (each are independent — use one per call).',
     annotations: { destructiveHint: false },
     inputSchema: {
       calendarId: z.string().describe('Calendar ID'),
@@ -73,9 +75,12 @@ export function registerCalendarTools(server: McpServer): void {
       description: z.string().optional().describe('New description'),
       location: z.string().optional().describe('New location'),
       attendees: z.string().optional().describe('New attendee emails, comma-separated (replaces existing)'),
+      withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event'),
+      regenerateZoom: z.boolean().optional().describe('Replace the event\'s existing Zoom video conference'),
+      removeZoom: z.boolean().optional().describe('Remove the event\'s Zoom video conference'),
       account: accountParam,
     },
-  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, account }) => {
+  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, withZoom, regenerateZoom, removeZoom, account }) => {
     const args = ['calendar', 'update', calendarId, eventId];
     if (summary !== undefined) args.push(`--summary=${summary}`);
     if (from !== undefined) args.push(`--from=${from}`);
@@ -83,6 +88,9 @@ export function registerCalendarTools(server: McpServer): void {
     if (description !== undefined) args.push(`--description=${description}`);
     if (location !== undefined) args.push(`--location=${location}`);
     if (attendees !== undefined) args.push(`--attendees=${attendees}`);
+    if (withZoom) args.push('--with-zoom');
+    if (regenerateZoom) args.push('--regenerate-zoom');
+    if (removeZoom) args.push('--remove-zoom');
     return runOrDiagnose(args, { account });
   });
 

package/src/tools/gmail.ts

@@ -4,7 +4,7 @@ import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
 
 export function registerGmailTools(server: McpServer): void {
   server.registerTool('gog_gmail_search', {
-    description: 'Search Gmail threads using Gmail query syntax (e.g. "from:alice subject:invoice is:unread").',
+    description: 'Search Gmail threads using Gmail query syntax (e.g. "from:alice subject:invoice is:unread"). The query is passed verbatim to Gmail; a bare name token (from:alison) matches per Gmail\'s own heuristics, a full address (from:alison@example.com) is exact. To match a contact across several addresses, OR them: from:(a@x.com OR b@y.com).',
     annotations: { readOnlyHint: true },
     inputSchema: {
       query: z.string().describe('Gmail search query'),

package/src/tools/sheets-a1.ts

@@ -0,0 +1,64 @@
+// A1-notation helpers for the fail_if_not_empty write guard. Kept separate
+// from sheets.ts so the pure range/value math is unit-testable in isolation.
+
+// 1 -> "A", 26 -> "Z", 27 -> "AA" (bijective base-26).
+function colToLetter(n: number): string {
+  let s = '';
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    s = String.fromCharCode(65 + rem) + s;
+    n = Math.floor((n - 1) / 26);
+  }
+  return s;
+}
+
+// "A" -> 1, "AA" -> 27.
+function letterToCol(s: string): number {
+  let n = 0;
+  for (const ch of s.toUpperCase()) {
+    n = n * 26 + (ch.charCodeAt(0) - 64);
+  }
+  return n;
+}
+
+// Given the target `range` of an update and the shape of the values being
+// written, return the range the guard should read to cover every written cell.
+//
+// A bare anchor cell ("Sheet1!A1") is expanded to the full written area
+// ("Sheet1!A1:D70"). An explicit range (contains ":") or a named range is
+// returned unchanged — the caller asked us to check exactly that span.
+export function expandAnchorRange(range: string, rows: number, cols: number): string {
+  const bang = range.lastIndexOf('!');
+  const sheet = bang >= 0 ? range.slice(0, bang + 1) : '';
+  const cell = bang >= 0 ? range.slice(bang + 1) : range;
+  const m = /^([A-Za-z]+)([0-9]+)$/.exec(cell);
+  if (!m) return range;
+  const startCol = letterToCol(m[1]);
+  const startRow = parseInt(m[2], 10);
+  const endCol = colToLetter(startCol + cols - 1);
+  const endRow = startRow + rows - 1;
+  return `${sheet}${m[1].toUpperCase()}${startRow}:${endCol}${endRow}`;
+}
+
+// Count cells holding data in the JSON output of `gog sheets get`
+// ({"values":[[...]]}). Empty strings and whitespace-only cells don't count;
+// numbers (including 0) and other primitives do. Returns -1 when the output
+// can't be parsed, so the caller can fail safe rather than assume "empty".
+export function countNonEmptyCells(getOutput: string): number {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(getOutput);
+  } catch {
+    return -1;
+  }
+  const values = (parsed as { values?: unknown })?.values;
+  if (!Array.isArray(values)) return 0;
+  let count = 0;
+  for (const row of values) {
+    if (!Array.isArray(row)) continue;
+    for (const cell of row) {
+      if (cell !== null && String(cell).trim() !== '') count++;
+    }
+  }
+  return count;
+}

package/src/tools/sheets.ts

@@ -1,12 +1,25 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
+import { run } from '../runner.js';
+import { accountParam, runOrDiagnose, registerRunTool, toText, diagnose } from './utils.js';
+import { expandAnchorRange, countNonEmptyCells } from './sheets-a1.js';
 
 // Cell value type: matches what gog sheets --values-json accepts (passed
 // straight to the Sheets API as userEnteredValue). Strings starting with
 // "=" are treated as formulas by gog's default --input=USER_ENTERED.
 const cellValueParam = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 
+// gog sheets update/append/clear all support -n/--dry-run ("Do not make
+// changes; print intended actions and exit successfully"). Exposing it gives
+// agents a no-op preview before committing a write to a live sheet.
+const dryRunParam = z.boolean().optional().describe(
+  'Preview the operation without modifying the sheet (gog --dry-run): reports the intended actions and exits without writing.',
+);
+
+const failIfNotEmptyParam = z.boolean().optional().describe(
+  'Safety guard against silent overwrites: before writing, read the target range and refuse the write if any target cell already holds data. Costs one extra read. Anchor ranges (e.g. "Sheet1!A1") are expanded to the full area your values will cover; explicit and named ranges are checked as-is.',
+);
+
 export function registerSheetsTools(server: McpServer): void {
   server.registerTool('gog_sheets_get', {
     description: 'Read values from a Google Sheets range. Returns a JSON object with a "values" array of rows.',
@@ -27,13 +40,37 @@ export function registerSheetsTools(server: McpServer): void {
       spreadsheetId: z.string().describe('Spreadsheet ID (from the URL)'),
       range: z.string().describe('Top-left cell or range in A1 notation, e.g. Sheet1!A1'),
       values: z.array(z.array(cellValueParam)).describe('2D array of values (rows of columns). Cells may be string/number/boolean/null; strings starting with "=" are formulas.'),
+      dry_run: dryRunParam,
+      fail_if_not_empty: failIfNotEmptyParam,
       account: accountParam,
     },
-  }, async ({ spreadsheetId, range, values, account }) => {
-    return runOrDiagnose(
-      ['sheets', 'update', spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
-      { account },
-    );
+  }, async ({ spreadsheetId, range, values, account, dry_run, fail_if_not_empty }) => {
+    const cols = values.reduce((max, row) => Math.max(max, row.length), 0);
+    if (fail_if_not_empty && values.length > 0 && cols > 0) {
+      const readRange = expandAnchorRange(range, values.length, cols);
+      let existing: string;
+      try {
+        existing = await run(['sheets', 'get', spreadsheetId, readRange], { account });
+      } catch (err) {
+        // Couldn't read the target — refuse to write rather than risk an
+        // overwrite, and diagnose the read failure (auth/transient/etc.) the
+        // same way runOrDiagnose would, since this path bypasses it.
+        return diagnose(err);
+      }
+      const occupied = countNonEmptyCells(existing);
+      if (occupied !== 0) {
+        const detail = occupied < 0
+          ? 'could not be verified as empty'
+          : `already contains data in ${occupied} cell(s)`;
+        return toText(
+          `Write aborted (fail_if_not_empty): target range ${readRange} ${detail}. ` +
+          'Re-run without fail_if_not_empty to overwrite, or clear it first with gog_sheets_clear.',
+        );
+      }
+    }
+    const args = ['sheets', 'update', spreadsheetId, range, `--values-json=${JSON.stringify(values)}`];
+    if (dry_run) args.push('--dry-run');
+    return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_sheets_append', {
@@ -43,13 +80,13 @@ export function registerSheetsTools(server: McpServer): void {
       spreadsheetId: z.string().describe('Spreadsheet ID (from the URL)'),
       range: z.string().describe('Range indicating which sheet/columns to append to, e.g. Sheet1!A:C'),
       values: z.array(z.array(cellValueParam)).describe('2D array of rows to append. Cells may be string/number/boolean/null; strings starting with "=" are formulas.'),
+      dry_run: dryRunParam,
       account: accountParam,
     },
-  }, async ({ spreadsheetId, range, values, account }) => {
-    return runOrDiagnose(
-      ['sheets', 'append', spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
-      { account },
-    );
+  }, async ({ spreadsheetId, range, values, account, dry_run }) => {
+    const args = ['sheets', 'append', spreadsheetId, range, `--values-json=${JSON.stringify(values)}`];
+    if (dry_run) args.push('--dry-run');
+    return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_sheets_clear', {
@@ -58,14 +95,17 @@ export function registerSheetsTools(server: McpServer): void {
     inputSchema: {
       spreadsheetId: z.string().describe('Spreadsheet ID'),
       range: z.string().describe('Range in A1 notation to clear'),
+      dry_run: dryRunParam,
       account: accountParam,
     },
-  }, async ({ spreadsheetId, range, account }) => {
-    return runOrDiagnose(['sheets', 'clear', spreadsheetId, range], { account });
+  }, async ({ spreadsheetId, range, account, dry_run }) => {
+    const args = ['sheets', 'clear', spreadsheetId, range];
+    if (dry_run) args.push('--dry-run');
+    return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_sheets_metadata', {
-    description: 'Get spreadsheet metadata: title, sheet tabs, named ranges, and other properties.',
+    description: 'Get spreadsheet metadata: title, named ranges, and per-tab properties including grid dimensions (gridProperties.rowCount / columnCount). Use this to learn a sheet\'s current size before writing — a write outside the grid fails.',
     annotations: { readOnlyHint: true },
     inputSchema: {
       spreadsheetId: z.string().describe('Spreadsheet ID'),

package/src/tools/utils.ts

@@ -5,7 +5,8 @@ import { run } from '../runner.js';
 export type ToolResult = { content: [{ type: 'text'; text: string }] };
 
 export const accountParam = z.string().optional().describe(
-  'Google account email to use (overrides GOG_ACCOUNT env var)',
+  'Google account email to use, e.g. you@gmail.com — must be the full address, not a bare username. ' +
+  'Overrides the GOG_ACCOUNT env var. Omit to use the single configured account.',
 );
 
 // Canonical ID descriptors. Use these instead of redefining the same
@@ -100,6 +101,11 @@ const AUTH_ERROR_PATTERN = /\b(401|unauthorized|token.*(expired|revoked)|invalid
 const TRANSIENT_ERROR_PATTERN =
   /\b429\b|\b5\d\d\b|\bquota\b|rateLimit|\bDEADLINE_EXCEEDED\b/i;
 
+// gogcli rejects writes whose range falls outside the sheet's current grid
+// (e.g. writing to column AP on a 41-column sheet) with a "exceeds grid limits"
+// error and no remediation. Point the caller at the tool that grows the grid.
+const GRID_LIMIT_ERROR_PATTERN = /exceeds grid limits/i;
+
 const AUTH_HINT =
   '\n\nAuthentication may have expired. Use gog_auth_add to re-authorize the account. ' +
   'Ask the user if they would like to re-authenticate.';
@@ -108,6 +114,57 @@ const TRANSIENT_HINT =
   '\n\nThis error is often transient. Retry the same call before trying a different approach ' +
   '(do not fall back to smaller writes or row-by-row operations).';
 
+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.';
+
+// 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
+// which were previously echoed verbatim on every failure. Falls back to the
+// trimmed raw text if the output isn't the expected JSON shape (e.g. a plain
+// email string), so unexpected output still degrades gracefully.
+export function formatAccountList(raw: string): string {
+  try {
+    const parsed = JSON.parse(raw) as { accounts?: unknown };
+    if (Array.isArray(parsed?.accounts)) {
+      return parsed.accounts
+        .map((a) => (a as { email?: string })?.email)
+        .filter(Boolean)
+        .join('\n');
+    }
+  } catch {
+    // not JSON — fall through to the raw text
+  }
+  return raw.trim();
+}
+
+// Turn a thrown error into a diagnosed ToolResult: the error text, an
+// actionable hint when the failure class is recognised (auth / transient /
+// off-grid write), and the list of configured accounts. Callers that need to
+// surface a failure without going through runOrDiagnose (e.g. a pre-write
+// verification read that must abort) can reuse this so the error keeps the
+// same diagnostic quality as everywhere else.
+export async function diagnose(err: unknown): Promise<ToolResult> {
+  const errText = toError(err).content[0].text;
+  const isAuthError = AUTH_ERROR_PATTERN.test(errText);
+  const isTransientError = !isAuthError && TRANSIENT_ERROR_PATTERN.test(errText);
+  const isGridLimitError = GRID_LIMIT_ERROR_PATTERN.test(errText);
+  const hint = isAuthError
+    ? AUTH_HINT
+    : isTransientError
+      ? TRANSIENT_HINT
+      : isGridLimitError
+        ? GRID_LIMIT_HINT
+        : '';
+  try {
+    const accounts = formatAccountList(await run(['auth', 'list']));
+    return toText(`${errText}\n\nConfigured accounts:\n${accounts || '(none)'}${hint}`);
+  } catch {
+    return toText(`${errText}${hint}`);
+  }
+}
+
 export async function runOrDiagnose(
   args: string[],
   options: { account?: string },
@@ -115,16 +172,6 @@ export async function runOrDiagnose(
   try {
     return toText(await run(args, options));
   } catch (err) {
-    const base = toError(err);
-    const errText = base.content[0].text;
-    const isAuthError = AUTH_ERROR_PATTERN.test(errText);
-    const isTransientError = !isAuthError && TRANSIENT_ERROR_PATTERN.test(errText);
-    const hint = isAuthError ? AUTH_HINT : isTransientError ? TRANSIENT_HINT : '';
-    try {
-      const accounts = await run(['auth', 'list']);
-      return toText(`${errText}\n\nConfigured accounts:\n${accounts}${hint}`);
-    } catch {
-      return toText(`${errText}${hint}`);
-    }
+    return diagnose(err);
   }
 }

package/tests/tools/calendar.test.ts

@@ -97,6 +97,41 @@ describe('gog_calendar_create', () => {
     );
   });
 
+  // gog 0.18.0: --with-zoom attaches a Zoom conference via description-mode
+  // integration (native conference card not supported for non-Workspace-Marketplace
+  // OAuth clients).
+  it('passes --with-zoom when withZoom is true', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_calendar_create')!({
+      calendarId: 'primary',
+      summary: 'Sync',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      withZoom: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      [
+        'calendar', 'create', 'primary',
+        '--summary=Sync', '--from=2026-04-14T09:00:00Z', '--to=2026-04-14T09:30:00Z',
+        '--with-zoom',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits --with-zoom when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_calendar_create')!({
+      calendarId: 'primary', summary: 's', from: 'f', to: 't', withZoom: false,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'create', 'primary', '--summary=s', '--from=f', '--to=t'],
+      { account: undefined },
+    );
+  });
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Create failed'));
     const handlers = setupHandlers();
@@ -143,6 +178,52 @@ describe('gog_calendar_update', () => {
     );
   });
 
+  // gog 0.18.0 Zoom flags: with-zoom adds, regenerate-zoom replaces, remove-zoom strips.
+  it('passes --with-zoom / --regenerate-zoom / --remove-zoom independently', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_calendar_update')!({
+      calendarId: 'primary', eventId: 'evt1', withZoom: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--with-zoom'],
+      { account: undefined },
+    );
+
+    vi.clearAllMocks();
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    await handlers.get('gog_calendar_update')!({
+      calendarId: 'primary', eventId: 'evt1', regenerateZoom: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--regenerate-zoom'],
+      { account: undefined },
+    );
+
+    vi.clearAllMocks();
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    await handlers.get('gog_calendar_update')!({
+      calendarId: 'primary', eventId: 'evt1', removeZoom: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--remove-zoom'],
+      { account: undefined },
+    );
+  });
+
+  it('omits zoom flags when all false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_calendar_update')!({
+      calendarId: 'primary', eventId: 'evt1',
+      withZoom: false, regenerateZoom: false, removeZoom: false,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1'],
+      { account: undefined },
+    );
+  });
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Update failed'));
     const handlers = setupHandlers();

package/tests/tools/sheets-a1.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { expandAnchorRange, countNonEmptyCells } from '../../src/tools/sheets-a1.js';
+
+describe('expandAnchorRange', () => {
+  it('expands a bare anchor cell to the full written area', () => {
+    expect(expandAnchorRange('A1', 3, 2)).toBe('A1:B3');
+  });
+
+  it('preserves a sheet-name prefix when expanding', () => {
+    expect(expandAnchorRange('Sheet1!A1', 70, 4)).toBe('Sheet1!A1:D70');
+  });
+
+  it('generates multi-letter end columns past Z', () => {
+    expect(expandAnchorRange('A1', 1, 27)).toBe('A1:AA1');
+  });
+
+  it('parses multi-letter start columns', () => {
+    expect(expandAnchorRange('AA5', 1, 1)).toBe('AA5:AA5');
+  });
+
+  it('uppercases a lowercase anchor column', () => {
+    expect(expandAnchorRange('b2', 1, 1)).toBe('B2:B2');
+  });
+
+  it('leaves an explicit A1 range (with a colon) unchanged', () => {
+    expect(expandAnchorRange('Sheet1!A1:D70', 5, 5)).toBe('Sheet1!A1:D70');
+  });
+
+  it('leaves a named range unchanged', () => {
+    expect(expandAnchorRange('MyNamedRange', 5, 5)).toBe('MyNamedRange');
+  });
+});
+
+describe('countNonEmptyCells', () => {
+  it('counts cells that hold data across ragged rows', () => {
+    expect(countNonEmptyCells('{"values":[["a","b"],["c"]]}')).toBe(3);
+  });
+
+  it('treats empty strings as empty', () => {
+    expect(countNonEmptyCells('{"values":[["","",""]]}')).toBe(0);
+  });
+
+  it('treats whitespace-only cells as empty', () => {
+    expect(countNonEmptyCells('{"values":[["   "]]}')).toBe(0);
+  });
+
+  it('counts numbers and zero as data, skips nulls', () => {
+    expect(countNonEmptyCells('{"values":[[1,0,null,"x"]]}')).toBe(3);
+  });
+
+  it('returns 0 when there is no values key', () => {
+    expect(countNonEmptyCells('{}')).toBe(0);
+  });
+
+  it('returns 0 when values is not an array', () => {
+    expect(countNonEmptyCells('{"values":"foo"}')).toBe(0);
+  });
+
+  it('returns 0 when the parsed JSON is null', () => {
+    expect(countNonEmptyCells('null')).toBe(0);
+  });
+
+  it('skips non-array rows', () => {
+    expect(countNonEmptyCells('{"values":[null,["a"]]}')).toBe(1);
+  });
+
+  it('returns -1 when the output is not valid JSON', () => {
+    expect(countNonEmptyCells('not json')).toBe(-1);
+  });
+});