gdocs-mcp 0.4.2 → 0.5.0

package/dist/index.js

@@ -30,7 +30,13 @@ import { DeleteDocumentSchema, deleteDocument } from './tools/delete-document.js
 import { GetCommentsSchema, getComments } from './tools/get-comments.js';
 import { AddCommentSchema, addComment } from './tools/add-comment.js';
 import { ReadDocumentStructureSchema, readDocumentStructure } from './tools/read-document-structure.js';
-const VERSION = '0.4.2';
+import { InsertTextSchema, insertText } from './tools/insert-text.js';
+import { DeleteContentRangeSchema, deleteContentRange } from './tools/delete-content-range.js';
+import { InsertTableRowSchema, insertTableRow, DeleteTableRowSchema, deleteTableRow, InsertTableColumnSchema, insertTableColumn, DeleteTableColumnSchema, deleteTableColumn } from './tools/table-row-column-ops.js';
+import { DeleteHeaderFooterSchema, deleteHeaderFooter } from './tools/delete-header-footer.js';
+import { CreateFootnoteSchema, createFootnote } from './tools/create-footnote.js';
+import { WriteTableSchema, writeTable } from './tools/write-table.js';
+const VERSION = '0.5.0';
 const QUIET = process.env.GDOCS_MCP_QUIET === '1';
 const server = new McpServer({
     name: 'gdocs-mcp',
@@ -128,6 +134,17 @@ registerTool('get_comments', 'List comments on a document with author, content,
 registerTool('add_comment', 'Add a comment anchored to specific text in the document. Anchors to first occurrence of quotedText.', AddCommentSchema, addComment);
 // v0.4.2 structure tool
 registerTool('read_document_structure', 'Return the structural outline of a Google Doc: paragraphs with indices, heading levels, text previews, tables with row/col counts, list metadata. Lightweight map for targeted edits.', ReadDocumentStructureSchema, readDocumentStructure);
+// v0.5 gap closure tools
+registerTool('insert_text', 'Insert text at a specific index or append to end of document.', InsertTextSchema, insertText);
+registerTool('delete_content_range', 'Delete a range of content. Supports preview mode (dry-run) to see what would be deleted before executing.', DeleteContentRangeSchema, deleteContentRange);
+registerTool('insert_table_row', 'Insert a row into an existing table. Zero-indexed.', InsertTableRowSchema, insertTableRow);
+registerTool('delete_table_row', 'Delete a row from an existing table. Zero-indexed.', DeleteTableRowSchema, deleteTableRow);
+registerTool('insert_table_column', 'Insert a column into an existing table. Zero-indexed.', InsertTableColumnSchema, insertTableColumn);
+registerTool('delete_table_column', 'Delete a column from an existing table. Zero-indexed.', DeleteTableColumnSchema, deleteTableColumn);
+registerTool('delete_header_footer', 'Delete a header or footer. Supports preview mode.', DeleteHeaderFooterSchema, deleteHeaderFooter);
+registerTool('create_footnote', 'Create a footnote at a specific position.', CreateFootnoteSchema, createFootnote);
+// v0.5 differentiator
+registerTool('write_table', 'Create a fully populated, styled table in one call. Inserts table, fills cells, applies header styling, sets content-aware column widths. Not safe for concurrent editing.', WriteTableSchema, writeTable);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/create-footnote.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const CreateFootnoteSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export declare function createFootnote(args: z.infer<typeof CreateFootnoteSchema>): Promise<{
+    documentId: string;
+    footnoteId: string | null | undefined;
+    index: number;
+    _apiMs: number;
+}>;

package/dist/tools/create-footnote.js

@@ -0,0 +1,25 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const CreateFootnoteSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    index: z.number().describe('Position in the document to insert the footnote reference'),
+});
+export async function createFootnote(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    const res = await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{ createFootnote: { location: { index: args.index } } }],
+        },
+    });
+    const footnoteId = res.data.replies?.[0]?.createFootnote?.footnoteId;
+    return {
+        documentId: args.documentId,
+        footnoteId,
+        index: args.index,
+        _apiMs: Math.round(performance.now() - apiStart),
+    };
+}

package/dist/tools/delete-content-range.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const DeleteContentRangeSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    startIndex: z.ZodNumber;
+    endIndex: z.ZodNumber;
+    preview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function deleteContentRange(args: z.infer<typeof DeleteContentRangeSchema>): Promise<{
+    documentId: string;
+    preview: boolean;
+    startIndex: number;
+    endIndex: number;
+    affectedElements: number;
+    affectedText: string;
+    _apiMs: number;
+    deleted?: undefined;
+} | {
+    documentId: string;
+    preview: boolean;
+    deleted: boolean;
+    startIndex: number;
+    endIndex: number;
+    affectedElements: number;
+    _apiMs: number;
+    affectedText?: undefined;
+}>;

package/dist/tools/delete-content-range.js

@@ -0,0 +1,69 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const DeleteContentRangeSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    startIndex: z.number().describe('Start index of the range to delete'),
+    endIndex: z.number().describe('End index of the range to delete (exclusive)'),
+    preview: z.boolean().optional().default(false).describe('If true, returns what would be deleted without executing. Use for dry-run safety checks.'),
+});
+export async function deleteContentRange(args) {
+    if (args.startIndex >= args.endIndex) {
+        throw new Error(`Invalid range: startIndex (${args.startIndex}) must be less than endIndex (${args.endIndex})`);
+    }
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    // Read document to validate range and get preview
+    const doc = await docs.documents.get({ documentId: args.documentId });
+    const content = doc.data.body?.content || [];
+    const lastIndex = content[content.length - 1]?.endIndex || 0;
+    if (args.endIndex > lastIndex) {
+        throw new Error(`Range exceeds document length. Document ends at index ${lastIndex}, but endIndex is ${args.endIndex}`);
+    }
+    // Build preview: count elements and collect text in the range
+    let affectedText = '';
+    let elementCount = 0;
+    for (const element of content) {
+        const elStart = element.startIndex ?? 0;
+        const elEnd = element.endIndex ?? 0;
+        if (elStart >= args.startIndex && elEnd <= args.endIndex) {
+            elementCount++;
+            if (element.paragraph) {
+                const text = element.paragraph.elements
+                    ?.map((el) => el.textRun?.content || '').join('') || '';
+                affectedText += text;
+            }
+        }
+    }
+    if (args.preview) {
+        const apiMs = Math.round(performance.now() - apiStart);
+        return {
+            documentId: args.documentId,
+            preview: true,
+            startIndex: args.startIndex,
+            endIndex: args.endIndex,
+            affectedElements: elementCount,
+            affectedText: affectedText.length > 200
+                ? affectedText.substring(0, 200) + '...'
+                : affectedText,
+            _apiMs: apiMs,
+        };
+    }
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{ deleteContentRange: { range: { startIndex: args.startIndex, endIndex: args.endIndex } } }],
+        },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        preview: false,
+        deleted: true,
+        startIndex: args.startIndex,
+        endIndex: args.endIndex,
+        affectedElements: elementCount,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/delete-header-footer.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const DeleteHeaderFooterSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    section: z.ZodEnum<{
+        header: "header";
+        footer: "footer";
+    }>;
+    preview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function deleteHeaderFooter(args: z.infer<typeof DeleteHeaderFooterSchema>): Promise<{
+    documentId: string;
+    section: "header" | "footer";
+    preview: boolean;
+    sectionId: string;
+    contentPreview: string;
+    _apiMs: number;
+    deleted?: undefined;
+} | {
+    documentId: string;
+    section: "header" | "footer";
+    deleted: boolean;
+    _apiMs: number;
+    preview?: undefined;
+    sectionId?: undefined;
+    contentPreview?: undefined;
+}>;

package/dist/tools/delete-header-footer.js

@@ -0,0 +1,45 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const DeleteHeaderFooterSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    section: z.enum(['header', 'footer']).describe('Which section to delete: "header" or "footer"'),
+    preview: z.boolean().optional().default(false).describe('If true, returns what would be deleted without executing.'),
+});
+export async function deleteHeaderFooter(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    const doc = await docs.documents.get({ documentId: args.documentId });
+    const isHeader = args.section === 'header';
+    const sections = isHeader ? doc.data.headers : doc.data.footers;
+    if (!sections || Object.keys(sections).length === 0) {
+        throw new Error(`No ${args.section} exists in this document.`);
+    }
+    const sectionId = Object.keys(sections)[0];
+    if (args.preview) {
+        const content = sections[sectionId]?.content || [];
+        const text = content.map((p) => p.paragraph?.elements?.map((e) => e.textRun?.content || '').join('')).join('').trim();
+        return {
+            documentId: args.documentId,
+            section: args.section,
+            preview: true,
+            sectionId,
+            contentPreview: text.length > 200 ? text.substring(0, 200) + '...' : text,
+            _apiMs: Math.round(performance.now() - apiStart),
+        };
+    }
+    const requestType = isHeader ? 'deleteHeader' : 'deleteFooter';
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{ [requestType]: { [isHeader ? 'headerId' : 'footerId']: sectionId } }],
+        },
+    });
+    return {
+        documentId: args.documentId,
+        section: args.section,
+        deleted: true,
+        _apiMs: Math.round(performance.now() - apiStart),
+    };
+}

package/dist/tools/insert-text.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const InsertTextSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    text: z.ZodString;
+    index: z.ZodOptional<z.ZodNumber>;
+    appendToEnd: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function insertText(args: z.infer<typeof InsertTextSchema>): Promise<{
+    documentId: string;
+    insertedAt: number;
+    textLength: number;
+    endIndex: number;
+    _apiMs: number;
+}>;

package/dist/tools/insert-text.js

@@ -0,0 +1,38 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const InsertTextSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    text: z.string().describe('Text to insert'),
+    index: z.number().optional().describe('Position to insert at. Required unless appendToEnd is true.'),
+    appendToEnd: z.boolean().optional().default(false).describe('Append text to the end of the document body. No need to know the last index.'),
+});
+export async function insertText(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    let insertIndex = args.index;
+    if (args.appendToEnd) {
+        const doc = await docs.documents.get({ documentId: args.documentId, fields: 'body.content(endIndex)' });
+        const content = doc.data.body?.content || [];
+        const lastElement = content[content.length - 1];
+        insertIndex = (lastElement?.endIndex || 1) - 1;
+    }
+    if (insertIndex === undefined) {
+        throw new Error('Either index or appendToEnd: true is required.');
+    }
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{ insertText: { location: { index: insertIndex }, text: args.text } }],
+        },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        insertedAt: insertIndex,
+        textLength: args.text.length,
+        endIndex: insertIndex + args.text.length,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/table-row-column-ops.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const InsertTableRowSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    tableStartIndex: z.ZodNumber;
+    rowIndex: z.ZodNumber;
+    insertBelow: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function insertTableRow(args: z.infer<typeof InsertTableRowSchema>): Promise<{
+    documentId: string;
+    inserted: boolean;
+    rowIndex: number;
+    _apiMs: number;
+}>;
+export declare const DeleteTableRowSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    tableStartIndex: z.ZodNumber;
+    rowIndex: z.ZodNumber;
+}, z.core.$strip>;
+export declare function deleteTableRow(args: z.infer<typeof DeleteTableRowSchema>): Promise<{
+    documentId: string;
+    deleted: boolean;
+    rowIndex: number;
+    _apiMs: number;
+}>;
+export declare const InsertTableColumnSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    tableStartIndex: z.ZodNumber;
+    columnIndex: z.ZodNumber;
+    insertRight: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function insertTableColumn(args: z.infer<typeof InsertTableColumnSchema>): Promise<{
+    documentId: string;
+    inserted: boolean;
+    columnIndex: number;
+    _apiMs: number;
+}>;
+export declare const DeleteTableColumnSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    tableStartIndex: z.ZodNumber;
+    columnIndex: z.ZodNumber;
+}, z.core.$strip>;
+export declare function deleteTableColumn(args: z.infer<typeof DeleteTableColumnSchema>): Promise<{
+    documentId: string;
+    deleted: boolean;
+    columnIndex: number;
+    _apiMs: number;
+}>;

package/dist/tools/table-row-column-ops.js

@@ -0,0 +1,107 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const InsertTableRowSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    tableStartIndex: z.number().describe('Start index of the table (from read_document_structure)'),
+    rowIndex: z.number().describe('Zero-indexed row position. New row is inserted below this row.'),
+    insertBelow: z.boolean().optional().default(true).describe('Insert below the specified row (default: true). Set false to insert above.'),
+});
+export async function insertTableRow(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{
+                    insertTableRow: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: args.tableStartIndex },
+                            rowIndex: args.rowIndex,
+                            columnIndex: 0,
+                        },
+                        insertBelow: args.insertBelow,
+                    },
+                }],
+        },
+    });
+    return { documentId: args.documentId, inserted: true, rowIndex: args.rowIndex, _apiMs: Math.round(performance.now() - apiStart) };
+}
+export const DeleteTableRowSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    tableStartIndex: z.number().describe('Start index of the table'),
+    rowIndex: z.number().describe('Zero-indexed row to delete'),
+});
+export async function deleteTableRow(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{
+                    deleteTableRow: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: args.tableStartIndex },
+                            rowIndex: args.rowIndex,
+                            columnIndex: 0,
+                        },
+                    },
+                }],
+        },
+    });
+    return { documentId: args.documentId, deleted: true, rowIndex: args.rowIndex, _apiMs: Math.round(performance.now() - apiStart) };
+}
+export const InsertTableColumnSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    tableStartIndex: z.number().describe('Start index of the table'),
+    columnIndex: z.number().describe('Zero-indexed column position. New column is inserted to the right.'),
+    insertRight: z.boolean().optional().default(true).describe('Insert to the right (default: true). Set false to insert left.'),
+});
+export async function insertTableColumn(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{
+                    insertTableColumn: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: args.tableStartIndex },
+                            rowIndex: 0,
+                            columnIndex: args.columnIndex,
+                        },
+                        insertRight: args.insertRight,
+                    },
+                }],
+        },
+    });
+    return { documentId: args.documentId, inserted: true, columnIndex: args.columnIndex, _apiMs: Math.round(performance.now() - apiStart) };
+}
+export const DeleteTableColumnSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    tableStartIndex: z.number().describe('Start index of the table'),
+    columnIndex: z.number().describe('Zero-indexed column to delete'),
+});
+export async function deleteTableColumn(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{
+                    deleteTableColumn: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: args.tableStartIndex },
+                            rowIndex: 0,
+                            columnIndex: args.columnIndex,
+                        },
+                    },
+                }],
+        },
+    });
+    return { documentId: args.documentId, deleted: true, columnIndex: args.columnIndex, _apiMs: Math.round(performance.now() - apiStart) };
+}

package/dist/tools/write-table.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const WriteTableSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    index: z.ZodNumber;
+    headers: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+    style: z.ZodOptional<z.ZodObject<{
+        headerBackground: z.ZodOptional<z.ZodString>;
+        headerTextColor: z.ZodOptional<z.ZodString>;
+        cellPadding: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function writeTable(args: z.infer<typeof WriteTableSchema>): Promise<{
+    documentId: string;
+    tableCreated: boolean;
+    styled: boolean;
+    reason: string;
+    rows?: undefined;
+    cols?: undefined;
+    tableStartIndex?: undefined;
+    requestCount?: undefined;
+    _apiMs?: undefined;
+} | {
+    documentId: string;
+    tableCreated: boolean;
+    styled: boolean;
+    rows: number;
+    cols: number;
+    tableStartIndex: any;
+    requestCount: number;
+    _apiMs: number;
+    reason?: undefined;
+}>;

package/dist/tools/write-table.js

@@ -0,0 +1,249 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+import { getPreset } from '../presets/config.js';
+const DEFAULT_HEADER_BG = { red: 0.043, green: 0.325, blue: 0.58 };
+const DEFAULT_HEADER_TEXT = { red: 0.95, green: 0.95, blue: 0.95 };
+const DEFAULT_PADDING = 5;
+const USABLE_PAGE_WIDTH = 468; // 612 - 72 - 72 (letter, 1in margins)
+const MAX_COL_RATIO = 0.35;
+const PT_PER_CHAR = 6;
+const PADDING_PER_COL = 20;
+export const WriteTableSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    index: z.number().describe('Position in the document to insert the table. Must be a body-level index, not inside an existing table.'),
+    headers: z.array(z.string()).min(1).max(20).describe('Column header labels'),
+    rows: z.array(z.array(z.string())).max(19).describe('Table data rows. Each row is an array of cell values matching the header count.'),
+    style: z.object({
+        headerBackground: z.string().optional(),
+        headerTextColor: z.string().optional(),
+        cellPadding: z.number().optional(),
+    }).optional().describe('Optional style overrides. Falls back to active preset, then defaults.'),
+});
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return {
+        red: parseInt(h.substring(0, 2), 16) / 255,
+        green: parseInt(h.substring(2, 4), 16) / 255,
+        blue: parseInt(h.substring(4, 6), 16) / 255,
+    };
+}
+export async function writeTable(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    const colCount = args.headers.length;
+    const rowCount = args.rows.length + 1; // headers + data rows
+    if (colCount > 20 || rowCount > 20) {
+        throw new Error(`Table exceeds Google Docs limit of 20x20. Requested: ${rowCount} rows x ${colCount} columns.`);
+    }
+    // Validate row lengths match header count
+    for (let i = 0; i < args.rows.length; i++) {
+        if (args.rows[i].length !== colCount) {
+            throw new Error(`Row ${i} has ${args.rows[i].length} cells but expected ${colCount} (matching headers).`);
+        }
+    }
+    // Step 1: Insert empty table
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [{ insertTable: { location: { index: args.index }, rows: rowCount, columns: colCount } }],
+        },
+    });
+    // Step 2: Re-read to get cell indices + validate
+    const doc = await docs.documents.get({ documentId: args.documentId });
+    const content = doc.data.body?.content || [];
+    let table = null;
+    for (const element of content) {
+        if (element.table && element.startIndex != null && element.startIndex >= args.index) {
+            table = element;
+            break;
+        }
+    }
+    if (!table) {
+        throw new Error('Table insertion failed: could not find the inserted table.');
+    }
+    if (table.table.rows !== rowCount || table.table.columns !== colCount) {
+        throw new Error(`Table dimension mismatch after insert. Expected ${rowCount}x${colCount}, found ${table.table.rows}x${table.table.columns}. ` +
+            'Document may have been modified concurrently.');
+    }
+    const tableStartIndex = table.startIndex;
+    // Build all cell data: [row][col] = { insertIndex, text }
+    const allData = [args.headers, ...args.rows];
+    const cellInserts = [];
+    for (let r = 0; r < table.table.tableRows.length; r++) {
+        for (let c = 0; c < table.table.tableRows[r].tableCells.length; c++) {
+            const cell = table.table.tableRows[r].tableCells[c];
+            const insertAt = cell.content[0].startIndex;
+            cellInserts.push({ index: insertAt, text: allData[r][c] });
+        }
+    }
+    // Step 3: Build all requests — insert text (reverse order), then style
+    const requests = [];
+    // Insert text in reverse order to avoid index shifts
+    const sortedInserts = [...cellInserts].sort((a, b) => b.index - a.index);
+    for (const { index, text } of sortedInserts) {
+        if (text) {
+            requests.push({ insertText: { location: { index }, text } });
+        }
+    }
+    // Execute text insertion first (indices shift after this)
+    if (requests.length > 0) {
+        await docs.documents.batchUpdate({
+            documentId: args.documentId,
+            requestBody: { requests },
+        });
+    }
+    // Step 4: Re-read again for styling (indices changed after text insertion)
+    const doc2 = await docs.documents.get({ documentId: args.documentId });
+    let table2 = null;
+    for (const element of doc2.data.body?.content || []) {
+        if (element.table && element.startIndex === tableStartIndex) {
+            table2 = element;
+            break;
+        }
+    }
+    // Find nearest table if exact match failed (startIndex may have shifted)
+    if (!table2) {
+        for (const element of doc2.data.body?.content || []) {
+            if (element.table && element.startIndex != null && element.startIndex >= args.index) {
+                table2 = element;
+                break;
+            }
+        }
+    }
+    if (!table2) {
+        return { documentId: args.documentId, tableCreated: true, styled: false, reason: 'Could not re-locate table for styling' };
+    }
+    // Resolve style
+    const resolvedStyle = resolveStyle(args.style);
+    const styleRequests = [];
+    // Bold header text + white color
+    const headerRow = table2.table.tableRows[0];
+    for (const cell of headerRow.tableCells) {
+        const start = cell.content[0].startIndex;
+        const end = cell.content[cell.content.length - 1].endIndex - 1;
+        if (end > start) {
+            styleRequests.push({
+                updateTextStyle: {
+                    range: { startIndex: start, endIndex: end },
+                    textStyle: {
+                        bold: true,
+                        foregroundColor: { color: { rgbColor: resolvedStyle.headerTextRgb } },
+                    },
+                    fields: 'bold,foregroundColor',
+                },
+            });
+        }
+    }
+    // Header row background
+    styleRequests.push({
+        updateTableCellStyle: {
+            tableRange: {
+                tableCellLocation: {
+                    tableStartLocation: { index: table2.startIndex },
+                    rowIndex: 0,
+                    columnIndex: 0,
+                },
+                rowSpan: 1,
+                columnSpan: colCount,
+            },
+            tableCellStyle: {
+                backgroundColor: { color: { rgbColor: resolvedStyle.headerBgRgb } },
+            },
+            fields: 'backgroundColor',
+        },
+    });
+    // Cell padding for all cells
+    const paddingMag = resolvedStyle.cellPadding;
+    styleRequests.push({
+        updateTableCellStyle: {
+            tableRange: {
+                tableCellLocation: {
+                    tableStartLocation: { index: table2.startIndex },
+                    rowIndex: 0,
+                    columnIndex: 0,
+                },
+                rowSpan: rowCount,
+                columnSpan: colCount,
+            },
+            tableCellStyle: {
+                paddingTop: { magnitude: paddingMag, unit: 'PT' },
+                paddingBottom: { magnitude: paddingMag, unit: 'PT' },
+                paddingLeft: { magnitude: paddingMag, unit: 'PT' },
+                paddingRight: { magnitude: paddingMag, unit: 'PT' },
+            },
+            fields: 'paddingTop,paddingBottom,paddingLeft,paddingRight',
+        },
+    });
+    // Content-aware column widths
+    const maxLengths = new Array(colCount).fill(0);
+    for (const row of allData) {
+        for (let c = 0; c < colCount; c++) {
+            maxLengths[c] = Math.max(maxLengths[c], (row[c] || '').length);
+        }
+    }
+    const totalLen = maxLengths.reduce((a, b) => a + b, 0);
+    if (totalLen > 0) {
+        for (let c = 0; c < colCount; c++) {
+            const contentWidth = maxLengths[c] * PT_PER_CHAR + PADDING_PER_COL;
+            const maxWidth = USABLE_PAGE_WIDTH * MAX_COL_RATIO;
+            const width = Math.min(Math.max(contentWidth, 50), maxWidth);
+            styleRequests.push({
+                updateTableColumnProperties: {
+                    tableStartLocation: { index: table2.startIndex },
+                    columnIndices: [c],
+                    tableColumnProperties: {
+                        widthType: 'FIXED_WIDTH',
+                        width: { magnitude: width, unit: 'PT' },
+                    },
+                    fields: 'widthType,width',
+                },
+            });
+        }
+    }
+    // Apply all styling
+    if (styleRequests.length > 0) {
+        await docs.documents.batchUpdate({
+            documentId: args.documentId,
+            requestBody: { requests: styleRequests },
+        });
+    }
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        tableCreated: true,
+        styled: true,
+        rows: rowCount,
+        cols: colCount,
+        tableStartIndex: table2.startIndex,
+        requestCount: requests.length + styleRequests.length,
+        _apiMs: apiMs,
+    };
+}
+function resolveStyle(explicit) {
+    let headerBgRgb = DEFAULT_HEADER_BG;
+    let headerTextRgb = DEFAULT_HEADER_TEXT;
+    let cellPadding = DEFAULT_PADDING;
+    // Try active preset
+    try {
+        const { preset } = getPreset();
+        if (preset.table?.headerBackground)
+            headerBgRgb = hexToRgb(preset.table.headerBackground);
+        if (preset.table?.headerTextColor)
+            headerTextRgb = hexToRgb(preset.table.headerTextColor);
+        if (preset.table?.cellPadding)
+            cellPadding = preset.table.cellPadding;
+    }
+    catch {
+        // No active preset, use defaults
+    }
+    // Explicit overrides
+    if (explicit?.headerBackground)
+        headerBgRgb = hexToRgb(explicit.headerBackground);
+    if (explicit?.headerTextColor)
+        headerTextRgb = hexToRgb(explicit.headerTextColor);
+    if (explicit?.cellPadding !== undefined)
+        cellPadding = explicit.cellPadding;
+    return { headerBgRgb, headerTextRgb, cellPadding };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdocs-mcp",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Open-source MCP server for Google Docs and Sheets. Self-hosted, local OAuth, no third-party token storage.",
   "type": "module",
   "main": "dist/index.js",