@triffon/google-docs-mcp 1.11.3-triffon

package/dist/index.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+// src/index.ts
+//
+// Single entry point for the Google Docs MCP Server.
+//
+// Usage:
+//   @a-bonus/google-docs-mcp          Start the MCP server (default)
+//   @a-bonus/google-docs-mcp auth     Run the interactive OAuth flow
+//
+// Remote mode (env vars):
+//   MCP_TRANSPORT=httpStream           Use Streamable HTTP instead of stdio
+//   BASE_URL=https://...               Public URL for OAuth redirects
+//   ALLOWED_DOMAINS=scio.cz,...        Restrict to specific Google Workspace domains
+import { FastMCP } from 'fastmcp';
+import { OAuthProxy } from 'fastmcp/auth';
+import { buildCachedToolsListPayload, collectToolsWhileRegistering, installCachedToolsListHandler, } from './cachedToolsList.js';
+import { initializeGoogleClient } from './clients.js';
+import { parseEnabledToolGroups, registerAllTools } from './tools/index.js';
+import { wrapServerForRemote } from './remoteWrapper.js';
+import { registerLandingPage } from './landingPage.js';
+import { registerDownloadRoute } from './downloadProxy.js';
+import { FirestoreTokenStorage } from './firestoreTokenStorage.js';
+import { parseStatelessFlag } from './config.js';
+import { enableUpstreamOfflineAccess } from './upstreamAuth.js';
+import { logger } from './logger.js';
+// --- Auth subcommand ---
+if (process.argv[2] === 'auth') {
+    const { runAuthFlow } = await import('./auth.js');
+    try {
+        await runAuthFlow();
+        logger.info('Authorization complete. You can now start the MCP server.');
+        process.exit(0);
+    }
+    catch (error) {
+        logger.error('Authorization failed:', error.message || error);
+        process.exit(1);
+    }
+}
+// --- Server startup ---
+process.on('uncaughtException', (error) => {
+    logger.error('Uncaught Exception:', error);
+    if (error.code === 'EPIPE' || error.code === 'ERR_STREAM_DESTROYED') {
+        process.exit(1);
+    }
+});
+process.on('unhandledRejection', (reason, _promise) => {
+    logger.error('Unhandled Promise Rejection:', reason);
+});
+process.stdin.on('end', () => {
+    logger.info('stdin closed — MCP host disconnected. Shutting down.');
+    process.exit(0);
+});
+process.stdin.on('error', () => {
+    process.exit(0);
+});
+// Graceful shutdown on termination signals.
+// Without these handlers, a host that sends SIGTERM (rather than closing
+// stdin) leaves the server running and accumulating in the background.
+const cleanShutdown = (signal) => {
+    logger.info(`Received ${signal} — shutting down.`);
+    process.exit(0);
+};
+process.on('SIGTERM', () => cleanShutdown('SIGTERM'));
+process.on('SIGINT', () => cleanShutdown('SIGINT'));
+process.on('SIGHUP', () => cleanShutdown('SIGHUP'));
+// Orphan-process watchdog (stdio mode only).
+// In practice, some MCP clients exit without sending SIGTERM, and the
+// stdin 'end' event can be swallowed by the transport's internal read
+// loop — leaving the server running as a zombie that consumes CPU and
+// memory indefinitely. As a backstop, detect reparenting to init
+// (PID 1) and exit. The check runs every 10 s and is unref()'d so it
+// does not keep the event loop alive on its own.
+if (process.env.MCP_TRANSPORT !== 'httpStream') {
+    const initialPpid = process.ppid;
+    const watchdog = setInterval(() => {
+        if (process.ppid !== initialPpid && process.ppid === 1) {
+            logger.info(`Parent process (was PID ${initialPpid}) exited; reparented to init. Shutting down.`);
+            process.exit(0);
+        }
+    }, 10_000);
+    watchdog.unref();
+}
+const isRemote = process.env.MCP_TRANSPORT === 'httpStream';
+if (isRemote) {
+    const missing = ['BASE_URL', 'GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET'].filter((k) => !process.env[k]);
+    if (missing.length > 0) {
+        logger.error(`FATAL: Missing required env vars for httpStream mode: ${missing.join(', ')}`);
+        process.exit(1);
+    }
+}
+const GOOGLE_API_SCOPES = [
+    'openid',
+    'email',
+    'https://www.googleapis.com/auth/documents',
+    'https://www.googleapis.com/auth/spreadsheets',
+    'https://www.googleapis.com/auth/drive',
+    'https://www.googleapis.com/auth/script.external_request',
+    'https://www.googleapis.com/auth/gmail.modify',
+    'https://www.googleapis.com/auth/calendar.events',
+];
+const oauthProxy = isRemote
+    ? new OAuthProxy({
+        upstreamAuthorizationEndpoint: 'https://accounts.google.com/o/oauth2/v2/auth',
+        upstreamTokenEndpoint: 'https://oauth2.googleapis.com/token',
+        upstreamClientId: process.env.GOOGLE_CLIENT_ID,
+        upstreamClientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        baseUrl: process.env.BASE_URL,
+        scopes: GOOGLE_API_SCOPES,
+        allowedRedirectUriPatterns: [
+            'http://localhost:*',
+            `${process.env.BASE_URL}/*`,
+            'cursor://*',
+            'https://claude.ai/*',
+            'https://claude.com/*',
+            'claude://*',
+        ],
+        jwtSigningKey: process.env.JWT_SIGNING_KEY,
+        encryptionKey: process.env.TOKEN_ENCRYPTION_KEY,
+        consentRequired: false,
+        accessTokenTtl: 2592000,
+        refreshTokenTtl: 2592000,
+        ...(process.env.TOKEN_STORE === 'firestore' && {
+            tokenStorage: new FirestoreTokenStorage(process.env.GCLOUD_PROJECT),
+        }),
+    })
+    : undefined;
+if (oauthProxy) {
+    // issueSwappedTokens() inlines the TTL logic: it checks
+    // upstreamTokens.expiresIn > 0 BEFORE config.accessTokenTtl.
+    // Google always returns expiresIn=3600, so our 30-day config is
+    // never reached. Zero it out so the config fallback is used.
+    const origIssue = oauthProxy.issueSwappedTokens.bind(oauthProxy);
+    oauthProxy.issueSwappedTokens = async function (clientId, upstreamTokens) {
+        if (this.config.accessTokenTtl) {
+            return origIssue(clientId, { ...upstreamTokens, expiresIn: 0 });
+        }
+        return origIssue(clientId, upstreamTokens);
+    };
+    enableUpstreamOfflineAccess(oauthProxy);
+}
+const server = new FastMCP({
+    name: 'Ultimate Google Docs & Sheets MCP Server',
+    version: '1.0.0',
+    ...(isRemote &&
+        oauthProxy && {
+        authenticate: async (request) => {
+            if (!request)
+                return undefined;
+            const authHeader = request.headers?.authorization;
+            if (!authHeader?.startsWith('Bearer '))
+                return undefined;
+            const token = authHeader.slice(7);
+            const upstreamTokens = await oauthProxy.loadUpstreamTokens(token);
+            if (!upstreamTokens)
+                return undefined;
+            return {
+                accessToken: upstreamTokens.accessToken,
+                refreshToken: upstreamTokens.refreshToken,
+                expiresAt: upstreamTokens.expiresIn
+                    ? Math.floor(Date.now() / 1000) + upstreamTokens.expiresIn
+                    : undefined,
+                idToken: upstreamTokens.idToken,
+                scopes: upstreamTokens.scope,
+            };
+        },
+        oauth: {
+            enabled: true,
+            authorizationServer: oauthProxy.getAuthorizationServerMetadata(),
+            protectedResource: {
+                authorizationServers: [process.env.BASE_URL],
+                resource: process.env.BASE_URL,
+                scopesSupported: GOOGLE_API_SCOPES,
+            },
+            proxy: oauthProxy,
+        },
+    }),
+});
+const registeredTools = [];
+collectToolsWhileRegistering(server, registeredTools);
+if (isRemote)
+    wrapServerForRemote(server);
+let enabledToolGroups;
+try {
+    enabledToolGroups = parseEnabledToolGroups();
+    registerAllTools(server, enabledToolGroups);
+    logger.info(`Registered tool groups: ${enabledToolGroups.join(', ')}.`);
+}
+catch (error) {
+    logger.error(`FATAL: Invalid MCP_TOOL_GROUPS: ${error.message || error}`);
+    process.exit(1);
+}
+try {
+    if (isRemote) {
+        logger.info('Starting in remote mode (httpStream + MCP OAuth 2.1)...');
+        registerLandingPage(server, registeredTools.length);
+        registerDownloadRoute(server);
+        const port = parseInt(process.env.PORT || '8080');
+        await server.start({
+            transportType: 'httpStream',
+            httpStream: {
+                port,
+                host: '0.0.0.0',
+                stateless: parseStatelessFlag(),
+            },
+        });
+        logger.info(`MCP Server running at ${process.env.BASE_URL || `http://0.0.0.0:${port}`}/mcp`);
+    }
+    else {
+        logger.info('Starting Ultimate Google Docs & Sheets MCP server...');
+        const cachedToolsList = await buildCachedToolsListPayload(registeredTools);
+        await server.start({ transportType: 'stdio' });
+        installCachedToolsListHandler(server, cachedToolsList);
+        logger.info('MCP Server running using stdio. Awaiting client connection...');
+        // Warm up the Google client *after* the transport is live, and never let it
+        // stop the server from running.
+        //
+        // Authorizing before server.start() meant a host could never complete the
+        // MCP `initialize` handshake when credentials were unavailable: missing
+        // credentials threw and the catch below called process.exit(1), while a
+        // missing saved token sent authorize() into the interactive browser flow,
+        // which blocks on a local callback server and hangs startup indefinitely.
+        // Either way the client saw "server exited" instead of a handshake.
+        //
+        // Tools already resolve the client lazily (getDocsClient() and friends call
+        // initializeGoogleClient() per request and raise a UserError when it fails),
+        // so deferring this costs nothing and keeps auth problems scoped to the
+        // calls that actually need Google.
+        void initializeGoogleClient().catch((authError) => {
+            logger.error(`Google authorization is not available yet: ${authError?.message || authError} ` +
+                'The server is running and will answer initialize and tools/list; individual tool ' +
+                'calls will fail until authorization succeeds. Run `npx @a-bonus/google-docs-mcp auth` ' +
+                'to complete the OAuth flow.');
+        });
+    }
+    logger.info('Process-level error handling configured to prevent crashes from timeout errors.');
+}
+catch (startError) {
+    logger.error('FATAL: Server failed to start:', startError.message || startError);
+    process.exit(1);
+}

package/dist/landingPage.js

@@ -0,0 +1,103 @@
+const TEXTS = {
+    en: {
+        title: 'Google Docs MCP Server',
+        subtitle: 'Model Context Protocol server for Google Docs, Sheets, Drive, Gmail & Calendar',
+        setup: 'Setup',
+        step1: 'Copy the configuration below',
+        step2: 'Open <strong>Cursor Settings → Tools &amp; MCP → Add new MCP server</strong>',
+        step3: 'Paste the JSON and save',
+        step4: 'Cursor will prompt you to sign in with Google on first use',
+        config: 'Cursor MCP Configuration',
+        copy: 'Copy',
+        copied: 'Copied!',
+        tools: 'tools available',
+        footer: 'Powered by <a href="https://github.com/a-bonus/google-docs-mcp">a-bonus/google-docs-mcp</a>',
+    },
+    cs: {
+        title: 'Google Docs MCP Server',
+        subtitle: 'Model Context Protocol server pro Google Docs, Sheets, Drive, Gmail &amp; Calendar',
+        setup: 'Nastavení',
+        step1: 'Zkopírujte konfiguraci níže',
+        step2: 'Otevřete <strong>Cursor Settings → Tools &amp; MCP → Add new MCP server</strong>',
+        step3: 'Vložte JSON a uložte',
+        step4: 'Cursor vás při prvním použití vyzve k přihlášení přes Google',
+        config: 'Konfigurace pro Cursor',
+        copy: 'Kopírovat',
+        copied: 'Zkopírováno!',
+        tools: 'dostupných nástrojů',
+        footer: 'Poháněno <a href="https://github.com/a-bonus/google-docs-mcp">a-bonus/google-docs-mcp</a>',
+    },
+};
+function pickLang(acceptLanguage) {
+    if (acceptLanguage?.toLowerCase().startsWith('cs'))
+        return 'cs';
+    return 'en';
+}
+function renderPage(lang, mcpUrl, toolCount) {
+    const t = TEXTS[lang];
+    const configJson = JSON.stringify({ mcpServers: { 'google-docs': { type: 'streamableHttp', url: mcpUrl } } }, null, 2);
+    return `<!DOCTYPE html>
+<html lang="${lang}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${t.title}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, -apple-system, sans-serif; background: #f8f9fa; color: #1a1a1a; line-height: 1.6; padding: 2rem 1rem; }
+    .container { max-width: 640px; margin: 0 auto; }
+    h1 { font-size: 1.75rem; font-weight: 700; margin-bottom: 0.25rem; }
+    .subtitle { color: #666; margin-bottom: 2rem; }
+    .badge { display: inline-block; background: #e8f5e9; color: #2e7d32; font-size: 0.8rem; font-weight: 600; padding: 0.2rem 0.6rem; border-radius: 99px; margin-left: 0.5rem; vertical-align: middle; }
+    h2 { font-size: 1.1rem; font-weight: 600; margin: 1.5rem 0 0.75rem; }
+    ol { padding-left: 1.5rem; margin-bottom: 1.5rem; }
+    li { margin-bottom: 0.4rem; }
+    .code-block { position: relative; background: #1e1e1e; color: #d4d4d4; border-radius: 8px; padding: 1rem; font-family: 'SF Mono', 'Fira Code', monospace; font-size: 0.85rem; overflow-x: auto; white-space: pre; margin-bottom: 1.5rem; }
+    .copy-btn { position: absolute; top: 0.5rem; right: 0.5rem; background: #333; color: #ccc; border: none; border-radius: 4px; padding: 0.3rem 0.6rem; font-size: 0.75rem; cursor: pointer; transition: background 0.2s; }
+    .copy-btn:hover { background: #555; }
+    .footer { margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #ddd; color: #888; font-size: 0.8rem; }
+    .footer a { color: #666; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>${t.title} <span class="badge">${toolCount} ${t.tools}</span></h1>
+    <p class="subtitle">${t.subtitle}</p>
+
+    <h2>${t.setup}</h2>
+    <ol>
+      <li>${t.step1}</li>
+      <li>${t.step2}</li>
+      <li>${t.step3}</li>
+      <li>${t.step4}</li>
+    </ol>
+
+    <h2>${t.config}</h2>
+    <div class="code-block"><button class="copy-btn" onclick="copyConfig()">${t.copy}</button><code id="config">${escapeHtml(configJson)}</code></div>
+
+    <p class="footer">${t.footer}</p>
+  </div>
+  <script>
+    var _cfg = ${JSON.stringify(configJson).replace(/</g, '\\u003c')};
+    function copyConfig() {
+      navigator.clipboard.writeText(_cfg);
+      var btn = document.querySelector('.copy-btn');
+      btn.textContent = '${t.copied}';
+      setTimeout(function() { btn.textContent = '${t.copy}'; }, 2000);
+    }
+  </script>
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function registerLandingPage(server, toolCount) {
+    const baseUrl = process.env.BASE_URL || '';
+    const mcpUrl = `${baseUrl}/mcp`;
+    const app = server.getApp();
+    app.get('/', (c) => {
+        const lang = pickLang(c.req.header('accept-language'));
+        return c.html(renderPage(lang, mcpUrl, toolCount));
+    });
+}

package/dist/logger.js

@@ -0,0 +1,58 @@
+// src/logger.ts
+//
+// Centralized logger with LOG_LEVEL support.
+//
+// Log levels (from most to least verbose):
+//   debug  - Detailed diagnostic info (text range mapping, request building, etc.)
+//   info   - General operational messages (server started, auth succeeded, etc.)
+//   warn   - Potentially harmful situations (missing content, fallback behavior)
+//   error  - Error conditions (API failures, auth failures, etc.)
+//
+// Set via the LOG_LEVEL environment variable. Defaults to "info".
+// Example: LOG_LEVEL=debug npm start
+//
+// MCP servers communicate over stdout, so all log output goes to stderr.
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+function resolveLevel() {
+    const env = process.env.LOG_LEVEL?.toLowerCase();
+    if (env && env in LOG_LEVELS) {
+        return env;
+    }
+    return 'info';
+}
+let currentLevel = resolveLevel();
+/** Re-read LOG_LEVEL from the environment (useful for testing). */
+export function refreshLogLevel() {
+    currentLevel = resolveLevel();
+}
+function shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+export const logger = {
+    debug(...args) {
+        if (shouldLog('debug')) {
+            console.error('[DEBUG]', ...args);
+        }
+    },
+    info(...args) {
+        if (shouldLog('info')) {
+            console.error('[INFO]', ...args);
+        }
+    },
+    warn(...args) {
+        if (shouldLog('warn')) {
+            console.error('[WARN]', ...args);
+        }
+    },
+    error(...args) {
+        if (shouldLog('error')) {
+            console.error('[ERROR]', ...args);
+        }
+    },
+};

package/dist/markdown-transformer/docsToMarkdown.js

@@ -0,0 +1,259 @@
+// src/markdown-transformer/docsToMarkdown.ts
+/**
+ * Font families used by the markdown-to-docs direction for code styling.
+ * When these are detected on a text run, we render backtick code in markdown.
+ */
+const CODE_FONT_FAMILIES = new Set(['Roboto Mono', 'Courier New', 'Consolas', 'monospace']);
+// --- Main Conversion ---
+/**
+ * Converts Google Docs JSON structure to a markdown string.
+ *
+ * Accepts the raw response from `docs.documents.get()`, or a subset with
+ * `{ body, lists }` (e.g. when extracting a specific tab).
+ *
+ * Handles headings, paragraphs, text formatting (bold, italic, strikethrough,
+ * underline, links, code), ordered & unordered lists with nesting, tables,
+ * and section breaks.
+ */
+export function docsJsonToMarkdown(docData) {
+    const body = docData.body;
+    if (!body?.content) {
+        return '';
+    }
+    const lists = docData.lists ?? {};
+    let markdown = '';
+    for (const element of body.content) {
+        if (element.paragraph) {
+            markdown += convertParagraph(element.paragraph, lists);
+        }
+        else if (element.table) {
+            markdown += convertTable(element.table);
+        }
+        else if (element.sectionBreak) {
+            markdown += '\n---\n\n';
+        }
+    }
+    return markdown.trim();
+}
+// --- Paragraph Conversion ---
+function convertParagraph(paragraph, lists) {
+    // 1. Determine paragraph type
+    const headingLevel = getHeadingLevel(paragraph);
+    const listInfo = getListInfo(paragraph, lists);
+    // 2. Extract text content with inline formatting
+    const elements = paragraph.elements ?? [];
+    const text = extractFormattedText(elements);
+    // 3. Format based on type
+    if (headingLevel && text.trim()) {
+        const hashes = '#'.repeat(Math.min(headingLevel, 6));
+        return `${hashes} ${text.trim()}\n\n`;
+    }
+    if (listInfo && text.trim()) {
+        const indent = '  '.repeat(listInfo.nestingLevel);
+        const marker = listInfo.ordered ? `1.` : `-`;
+        return `${indent}${marker} ${text.trim()}\n`;
+    }
+    if (text.trim()) {
+        return `${text.trim()}\n\n`;
+    }
+    return '\n';
+}
+// --- Heading Detection ---
+function getHeadingLevel(paragraph) {
+    const styleType = paragraph.paragraphStyle?.namedStyleType;
+    if (!styleType)
+        return null;
+    if (styleType === 'TITLE')
+        return 1;
+    if (styleType === 'SUBTITLE')
+        return 2;
+    const match = styleType.match(/^HEADING_(\d)$/);
+    return match ? parseInt(match[1], 10) : null;
+}
+function getListInfo(paragraph, lists) {
+    if (!paragraph.bullet)
+        return null;
+    const nestingLevel = paragraph.bullet.nestingLevel ?? 0;
+    const listId = paragraph.bullet.listId;
+    let ordered = false;
+    if (listId && lists[listId]?.listProperties?.nestingLevels) {
+        const nestingLevels = lists[listId].listProperties.nestingLevels;
+        const level = nestingLevels[nestingLevel];
+        if (level) {
+            // glyphType is set for ordered lists (e.g., DECIMAL, ALPHA, ROMAN)
+            // glyphSymbol is set for unordered lists (e.g., bullet characters)
+            // If glyphType is present and not empty, it's ordered
+            if (level.glyphType && level.glyphType !== 'GLYPH_TYPE_UNSPECIFIED') {
+                ordered = true;
+            }
+        }
+    }
+    return { ordered, nestingLevel };
+}
+// --- Text Run Conversion ---
+function extractFormattedText(elements) {
+    let result = '';
+    for (const element of elements) {
+        if (element.textRun) {
+            result += convertTextRun(element.textRun);
+        }
+    }
+    return result;
+}
+function convertTextRun(textRun) {
+    let text = textRun.content ?? '';
+    const style = textRun.textStyle;
+    if (!style)
+        return text;
+    // Detect code-styled text (monospace font) -- wrap in backticks and skip
+    // other formatting since markdown code spans don't support nested formatting.
+    if (isCodeStyled(style)) {
+        const trimmed = text.replace(/\n$/, '');
+        if (trimmed) {
+            return `\`${trimmed}\`${text.endsWith('\n') ? '\n' : ''}`;
+        }
+        return text;
+    }
+    // Strip trailing newline before applying formatting markers, then re-add.
+    // This prevents markers from wrapping the newline (e.g., "**text\n**").
+    const trailingNewline = text.endsWith('\n');
+    const content = trailingNewline ? text.slice(0, -1) : text;
+    if (!content)
+        return text;
+    let formatted = content;
+    // Apply inline formatting (bold + italic combined, or individually)
+    if (style.bold && style.italic) {
+        formatted = `***${formatted}***`;
+    }
+    else if (style.bold) {
+        formatted = `**${formatted}**`;
+    }
+    else if (style.italic) {
+        formatted = `*${formatted}*`;
+    }
+    if (style.strikethrough) {
+        formatted = `~~${formatted}~~`;
+    }
+    if (style.underline && !style.link) {
+        formatted = `<u>${formatted}</u>`;
+    }
+    if (style.link?.url) {
+        formatted = `[${formatted}](${style.link.url})`;
+    }
+    return formatted + (trailingNewline ? '\n' : '');
+}
+function isCodeStyled(style) {
+    const fontFamily = style.weightedFontFamily?.fontFamily;
+    return typeof fontFamily === 'string' && CODE_FONT_FAMILIES.has(fontFamily);
+}
+// --- Table Conversion ---
+function convertTable(table) {
+    if (!table.tableRows || table.tableRows.length === 0) {
+        return '';
+    }
+    // Detect code block tables (1x1 table with monospace font or gray background)
+    if (isCodeBlockTable(table)) {
+        return convertCodeBlockTable(table);
+    }
+    let markdown = '\n';
+    let isFirstRow = true;
+    for (const row of table.tableRows) {
+        if (!row.tableCells)
+            continue;
+        let rowText = '|';
+        for (const cell of row.tableCells) {
+            const cellText = extractCellText(cell);
+            rowText += ` ${cellText} |`;
+        }
+        markdown += rowText + '\n';
+        // Add header separator after the first row
+        if (isFirstRow) {
+            let separator = '|';
+            for (let i = 0; i < row.tableCells.length; i++) {
+                separator += ' --- |';
+            }
+            markdown += separator + '\n';
+            isFirstRow = false;
+        }
+    }
+    return markdown + '\n';
+}
+/**
+ * Detects if a table is a code block (1x1 table with monospace font or gray background).
+ * Google Docs "Code Block" building blocks are represented as styled 1x1 tables.
+ */
+function isCodeBlockTable(table) {
+    // Must be a 1x1 table
+    if (!table.tableRows || table.tableRows.length !== 1)
+        return false;
+    const row = table.tableRows[0];
+    if (!row.tableCells || row.tableCells.length !== 1)
+        return false;
+    const cell = row.tableCells[0];
+    // Check for gray/colored background on the cell
+    const cellStyle = cell.tableCellStyle;
+    if (cellStyle?.backgroundColor?.color?.rgbColor) {
+        const bg = cellStyle.backgroundColor.color.rgbColor;
+        // Detect light gray backgrounds (typical of code blocks)
+        // Allow a range of light grays
+        const r = bg.red ?? 0;
+        const g = bg.green ?? 0;
+        const b = bg.blue ?? 0;
+        if (r > 0.85 && g > 0.85 && b > 0.85 && r < 1 && g < 1 && b < 1) {
+            return true;
+        }
+    }
+    // Check for monospace font in cell content
+    if (cell.content) {
+        for (const element of cell.content) {
+            if (element.paragraph?.elements) {
+                for (const pe of element.paragraph.elements) {
+                    if (pe.textRun?.textStyle) {
+                        if (isCodeStyled(pe.textRun.textStyle)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Converts a code block table (1x1 table) to a fenced markdown code block.
+ */
+function convertCodeBlockTable(table) {
+    const cell = table.tableRows[0].tableCells[0];
+    let codeText = '';
+    if (cell.content) {
+        for (const element of cell.content) {
+            if (element.paragraph?.elements) {
+                for (const pe of element.paragraph.elements) {
+                    if (pe.textRun?.content) {
+                        codeText += pe.textRun.content;
+                    }
+                }
+            }
+        }
+    }
+    // Remove trailing newline (cells always end with one)
+    if (codeText.endsWith('\n')) {
+        codeText = codeText.slice(0, -1);
+    }
+    return '\n```\n' + codeText + '\n```\n\n';
+}
+function extractCellText(cell) {
+    let text = '';
+    if (!cell.content)
+        return text;
+    for (const element of cell.content) {
+        if (element.paragraph?.elements) {
+            for (const pe of element.paragraph.elements) {
+                if (pe.textRun?.content) {
+                    text += pe.textRun.content.replace(/\n/g, ' ').trim();
+                }
+            }
+        }
+    }
+    return text;
+}