gdocs-mcp 0.3.0 → 0.4.0

package/dist/auth/google-auth.d.ts

@@ -3,6 +3,7 @@ declare const CONFIG_DIR: string;
 declare const TOKEN_PATH: string;
 declare const CREDENTIALS_PATH_DEFAULT: string;
 export declare function getAuthClient(): OAuth2Client;
+export declare function isReadOnlyMode(): boolean;
 export declare function getConfigDir(): string;
 export declare function getTokenPath(): string;
 export declare function getScopes(): string[];

package/dist/auth/google-auth.js

@@ -4,7 +4,13 @@ import path from 'path';
 const CONFIG_DIR = path.join(process.env.HOME || '~', '.gdocs-mcp');
 const TOKEN_PATH = path.join(CONFIG_DIR, 'token.json');
 const CREDENTIALS_PATH_DEFAULT = path.join(CONFIG_DIR, 'credentials.json');
-const SCOPES = [
+const READONLY = process.env.GDOCS_MCP_READONLY === '1';
+const FULL_SCOPES = [
+    'https://www.googleapis.com/auth/documents',
+    'https://www.googleapis.com/auth/spreadsheets.readonly',
+    'https://www.googleapis.com/auth/drive',
+];
+const READONLY_SCOPES = [
     'https://www.googleapis.com/auth/documents',
     'https://www.googleapis.com/auth/spreadsheets.readonly',
     'https://www.googleapis.com/auth/drive.readonly',
@@ -31,6 +37,16 @@ export function getAuthClient() {
         throw new Error('Auth required. Run: npx gdocs-mcp auth');
     }
     const token = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
+    // Check if token has sufficient scopes for full mode
+    if (!READONLY && token.scope) {
+        const grantedScopes = token.scope.split(' ');
+        const hasDriveWrite = grantedScopes.some((s) => s === 'https://www.googleapis.com/auth/drive');
+        if (!hasDriveWrite) {
+            throw new Error('Auth scopes insufficient. v0.4 requires expanded Drive access for export, copy, delete, and comments.\n' +
+                'Run: npx gdocs-mcp auth\n' +
+                'Or set GDOCS_MCP_READONLY=1 to use read-only mode with the original scope.');
+        }
+    }
     oAuth2Client.setCredentials(token);
     oAuth2Client.on('tokens', (newTokens) => {
         const existing = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
@@ -39,6 +55,9 @@ export function getAuthClient() {
     });
     return oAuth2Client;
 }
+export function isReadOnlyMode() {
+    return READONLY;
+}
 export function getConfigDir() {
     return CONFIG_DIR;
 }
@@ -46,6 +65,6 @@ export function getTokenPath() {
     return TOKEN_PATH;
 }
 export function getScopes() {
-    return SCOPES;
+    return READONLY ? READONLY_SCOPES : FULL_SCOPES;
 }
 export { CONFIG_DIR, TOKEN_PATH, CREDENTIALS_PATH_DEFAULT };

package/dist/index.js

@@ -20,7 +20,16 @@ import { DeleteStylePresetSchema, deleteStylePreset } from './tools/delete-style
 import { UpdateHeaderFooterSchema, updateHeaderFooter } from './tools/update-header-footer.js';
 import { FormatListSchema, formatList } from './tools/format-list.js';
 import { ExecuteScriptSchema, executeScript } from './tools/execute-script.js';
-const VERSION = '0.3.0';
+import { InsertImageSchema, insertImage } from './tools/insert-image.js';
+import { InsertTableSchema, insertTable } from './tools/insert-table.js';
+import { InsertPageBreakSchema, insertPageBreak } from './tools/insert-page-break.js';
+import { InsertLinkSchema, insertLink } from './tools/insert-link.js';
+import { ExportDocumentSchema, exportDocument } from './tools/export-document.js';
+import { CopyDocumentSchema, copyDocument } from './tools/copy-document.js';
+import { DeleteDocumentSchema, deleteDocument } from './tools/delete-document.js';
+import { GetCommentsSchema, getComments } from './tools/get-comments.js';
+import { AddCommentSchema, addComment } from './tools/add-comment.js';
+const VERSION = '0.4.0';
 const QUIET = process.env.GDOCS_MCP_QUIET === '1';
 const server = new McpServer({
     name: 'gdocs-mcp',
@@ -106,6 +115,16 @@ registerTool('delete_style_preset', 'Delete a user-defined style preset. Cannot
 registerTool('update_header_footer', 'Create or update header/footer content and styling. Supports page number insertion.', UpdateHeaderFooterSchema, updateHeaderFooter);
 registerTool('format_list', 'Apply bullet, numbered, or remove list formatting on a paragraph range. Supports 6 glyph presets.', FormatListSchema, formatList);
 registerTool('execute_script', 'Execute a function in a deployed Google Apps Script project. Returns JSON result.', ExecuteScriptSchema, executeScript);
+// v0.4 content tools
+registerTool('insert_image', 'Insert an image from a URL at a specific position. Supports optional width/height sizing in PT.', InsertImageSchema, insertImage);
+registerTool('insert_table', 'Create a table with specified rows (1-20) and columns (1-20) at a position.', InsertTableSchema, insertTable);
+registerTool('insert_page_break', 'Insert a page break at a specific position.', InsertPageBreakSchema, insertPageBreak);
+registerTool('insert_link', 'Add a hyperlink to an existing text range. The text must already exist in the document.', InsertLinkSchema, insertLink);
+registerTool('export_document', 'Export a Google Doc as PDF, DOCX, TXT, or HTML. Saves to file or returns base64.', ExportDocumentSchema, exportDocument);
+registerTool('copy_document', 'Create a copy of a Google Doc with a new title. Inherits content and formatting.', CopyDocumentSchema, copyDocument);
+registerTool('delete_document', 'Move a Google Doc to trash. Requires confirmTitle matching the exact document title.', DeleteDocumentSchema, deleteDocument);
+registerTool('get_comments', 'List comments on a document with author, content, resolved status, and replies.', GetCommentsSchema, getComments);
+registerTool('add_comment', 'Add a comment anchored to specific text in the document. Anchors to first occurrence of quotedText.', AddCommentSchema, addComment);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/add-comment.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const AddCommentSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    content: z.ZodString;
+    quotedText: z.ZodString;
+}, z.core.$strip>;
+export declare function addComment(args: z.infer<typeof AddCommentSchema>): Promise<{
+    documentId: string;
+    commentId: string | null | undefined;
+    content: string | null | undefined;
+    quotedText: string | undefined;
+    createdTime: string | null | undefined;
+    _apiMs: number;
+}>;

package/dist/tools/add-comment.js

@@ -0,0 +1,36 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient, isReadOnlyMode } from '../auth/google-auth.js';
+export const AddCommentSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    content: z.string().describe('The comment text'),
+    quotedText: z.string().describe('Text in the document to anchor the comment to. Google matches the first occurrence.'),
+});
+export async function addComment(args) {
+    if (isReadOnlyMode()) {
+        throw new Error('add_comment is not available in read-only mode. Remove GDOCS_MCP_READONLY=1 and re-auth.');
+    }
+    const auth = getAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    const apiStart = performance.now();
+    const res = await drive.comments.create({
+        fileId: args.documentId,
+        fields: 'id,author(displayName),content,quotedFileContent,createdTime',
+        requestBody: {
+            content: args.content,
+            quotedFileContent: {
+                value: args.quotedText,
+                mimeType: 'text/html',
+            },
+        },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        commentId: res.data.id,
+        content: res.data.content,
+        quotedText: res.data.quotedFileContent?.value,
+        createdTime: res.data.createdTime,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/copy-document.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const CopyDocumentSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    newTitle: z.ZodString;
+}, z.core.$strip>;
+export declare function copyDocument(args: z.infer<typeof CopyDocumentSchema>): Promise<{
+    originalDocumentId: string;
+    newDocumentId: string | null | undefined;
+    title: string | null | undefined;
+    url: string | null | undefined;
+    _apiMs: number;
+}>;

package/dist/tools/copy-document.js

@@ -0,0 +1,28 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient, isReadOnlyMode } from '../auth/google-auth.js';
+export const CopyDocumentSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID to copy'),
+    newTitle: z.string().describe('Title for the copy'),
+});
+export async function copyDocument(args) {
+    if (isReadOnlyMode()) {
+        throw new Error('copy_document is not available in read-only mode. Remove GDOCS_MCP_READONLY=1 and re-auth.');
+    }
+    const auth = getAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    const apiStart = performance.now();
+    const res = await drive.files.copy({
+        fileId: args.documentId,
+        requestBody: { name: args.newTitle },
+        fields: 'id, name, webViewLink',
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        originalDocumentId: args.documentId,
+        newDocumentId: res.data.id,
+        title: res.data.name,
+        url: res.data.webViewLink,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/delete-document.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const DeleteDocumentSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    confirmTitle: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteDocument(args: z.infer<typeof DeleteDocumentSchema>): Promise<{
+    documentId: string;
+    title: string;
+    trashed: boolean;
+    message: string;
+    _apiMs: number;
+}>;

package/dist/tools/delete-document.js

@@ -0,0 +1,36 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient, isReadOnlyMode } from '../auth/google-auth.js';
+export const DeleteDocumentSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID to trash'),
+    confirmTitle: z.string().describe('Must match the exact document title to confirm deletion. This prevents accidental trashing.'),
+});
+export async function deleteDocument(args) {
+    if (isReadOnlyMode()) {
+        throw new Error('delete_document is not available in read-only mode. Remove GDOCS_MCP_READONLY=1 and re-auth.');
+    }
+    const auth = getAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    const apiStart = performance.now();
+    // Get the actual document title
+    const file = await drive.files.get({
+        fileId: args.documentId,
+        fields: 'name',
+    });
+    const actualTitle = file.data.name;
+    if (args.confirmTitle !== actualTitle) {
+        throw new Error(`Confirmation failed. To trash this document, pass confirmTitle: "${actualTitle}"`);
+    }
+    await drive.files.update({
+        fileId: args.documentId,
+        requestBody: { trashed: true },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        title: actualTitle,
+        trashed: true,
+        message: 'Document moved to trash. It can be recovered from Google Drive trash.',
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/export-document.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const ExportDocumentSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    format: z.ZodEnum<{
+        pdf: "pdf";
+        docx: "docx";
+        txt: "txt";
+        html: "html";
+    }>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function exportDocument(args: z.infer<typeof ExportDocumentSchema>): Promise<{
+    documentId: string;
+    format: "pdf" | "docx" | "txt" | "html";
+    savedTo: string;
+    sizeBytes: number;
+    _apiMs: number;
+    content?: undefined;
+} | {
+    documentId: string;
+    format: "pdf" | "docx" | "txt" | "html";
+    content: string;
+    sizeBytes: number;
+    _apiMs: number;
+    savedTo?: undefined;
+}>;

package/dist/tools/export-document.js

@@ -0,0 +1,43 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import fs from 'fs';
+import { getAuthClient, isReadOnlyMode } from '../auth/google-auth.js';
+const MIME_TYPES = {
+    pdf: 'application/pdf',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    txt: 'text/plain',
+    html: 'text/html',
+};
+export const ExportDocumentSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    format: z.enum(['pdf', 'docx', 'txt', 'html']).describe('Export format: pdf, docx, txt, or html'),
+    outputPath: z.string().optional().describe('Local file path to save the export. If omitted, returns base64-encoded content.'),
+});
+export async function exportDocument(args) {
+    if (isReadOnlyMode()) {
+        throw new Error('export_document is not available in read-only mode. Remove GDOCS_MCP_READONLY=1 and re-auth.');
+    }
+    const auth = getAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    const apiStart = performance.now();
+    const res = await drive.files.export({ fileId: args.documentId, mimeType: MIME_TYPES[args.format] }, { responseType: 'arraybuffer' });
+    const buffer = Buffer.from(res.data);
+    const apiMs = Math.round(performance.now() - apiStart);
+    if (args.outputPath) {
+        fs.writeFileSync(args.outputPath, buffer);
+        return {
+            documentId: args.documentId,
+            format: args.format,
+            savedTo: args.outputPath,
+            sizeBytes: buffer.length,
+            _apiMs: apiMs,
+        };
+    }
+    return {
+        documentId: args.documentId,
+        format: args.format,
+        content: buffer.toString('base64'),
+        sizeBytes: buffer.length,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/get-comments.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const GetCommentsSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    includeResolved: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function getComments(args: z.infer<typeof GetCommentsSchema>): Promise<{
+    documentId: string;
+    comments: {
+        id: string | null | undefined;
+        author: string;
+        authorEmail: string | null | undefined;
+        content: string | null | undefined;
+        quotedText: string | null;
+        resolved: boolean;
+        createdTime: string | null | undefined;
+        modifiedTime: string | null | undefined;
+        replies: {
+            author: string;
+            content: string | null | undefined;
+            createdTime: string | null | undefined;
+        }[];
+    }[];
+    count: number;
+    _apiMs: number;
+}>;

package/dist/tools/get-comments.js

@@ -0,0 +1,44 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient, isReadOnlyMode } from '../auth/google-auth.js';
+export const GetCommentsSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    includeResolved: z.boolean().optional().default(false).describe('Include resolved comments (default: false, only open comments)'),
+});
+export async function getComments(args) {
+    if (isReadOnlyMode()) {
+        throw new Error('get_comments is not available in read-only mode. Remove GDOCS_MCP_READONLY=1 and re-auth.');
+    }
+    const auth = getAuthClient();
+    const drive = google.drive({ version: 'v3', auth });
+    const apiStart = performance.now();
+    const res = await drive.comments.list({
+        fileId: args.documentId,
+        fields: 'comments(id,author(displayName,emailAddress),content,quotedFileContent,resolved,createdTime,modifiedTime,replies(author(displayName),content,createdTime))',
+        pageSize: 100,
+    });
+    const comments = (res.data.comments || [])
+        .filter(c => args.includeResolved || !c.resolved)
+        .map(c => ({
+        id: c.id,
+        author: c.author?.displayName || 'Unknown',
+        authorEmail: c.author?.emailAddress,
+        content: c.content,
+        quotedText: c.quotedFileContent?.value || null,
+        resolved: c.resolved || false,
+        createdTime: c.createdTime,
+        modifiedTime: c.modifiedTime,
+        replies: (c.replies || []).map(r => ({
+            author: r.author?.displayName || 'Unknown',
+            content: r.content,
+            createdTime: r.createdTime,
+        })),
+    }));
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        comments,
+        count: comments.length,
+        _apiMs: apiMs,
+    };
+}

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const InsertImageSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    uri: z.ZodString;
+    index: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function insertImage(args: z.infer<typeof InsertImageSchema>): Promise<{
+    documentId: string;
+    inlineObjectId: string | null | undefined;
+    index: number;
+    _apiMs: number;
+}>;

package/dist/tools/insert-image.js

@@ -0,0 +1,43 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const InsertImageSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    uri: z.string().url().describe('Public URL of the image to insert'),
+    index: z.number().describe('Position in the document to insert the image'),
+    width: z.number().optional().describe('Image width in PT. If only width is set, height scales proportionally.'),
+    height: z.number().optional().describe('Image height in PT. If only height is set, width scales proportionally.'),
+});
+export async function insertImage(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    const objectSize = {};
+    if (args.width !== undefined) {
+        objectSize.width = { magnitude: args.width, unit: 'PT' };
+    }
+    if (args.height !== undefined) {
+        objectSize.height = { magnitude: args.height, unit: 'PT' };
+    }
+    const request = {
+        insertInlineImage: {
+            location: { index: args.index },
+            uri: args.uri,
+        },
+    };
+    if (Object.keys(objectSize).length > 0) {
+        request.insertInlineImage.objectSize = objectSize;
+    }
+    const res = await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: { requests: [request] },
+    });
+    const inlineObjectId = res.data.replies?.[0]?.insertInlineImage?.objectId;
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        inlineObjectId,
+        index: args.index,
+        _apiMs: apiMs,
+    };
+}

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const InsertLinkSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    url: z.ZodString;
+    startIndex: z.ZodNumber;
+    endIndex: z.ZodNumber;
+}, z.core.$strip>;
+export declare function insertLink(args: z.infer<typeof InsertLinkSchema>): Promise<{
+    documentId: string;
+    url: string;
+    startIndex: number;
+    endIndex: number;
+    _apiMs: number;
+}>;

package/dist/tools/insert-link.js

@@ -0,0 +1,38 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const InsertLinkSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    url: z.string().url().describe('The URL to link to'),
+    startIndex: z.number().describe('Start index of the text range to make into a link'),
+    endIndex: z.number().describe('End index of the text range to make into a link'),
+});
+export async function insertLink(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [
+                {
+                    updateTextStyle: {
+                        range: { startIndex: args.startIndex, endIndex: args.endIndex },
+                        textStyle: {
+                            link: { url: args.url },
+                        },
+                        fields: 'link',
+                    },
+                },
+            ],
+        },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        url: args.url,
+        startIndex: args.startIndex,
+        endIndex: args.endIndex,
+        _apiMs: apiMs,
+    };
+}

package/dist/tools/insert-page-break.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const InsertPageBreakSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export declare function insertPageBreak(args: z.infer<typeof InsertPageBreakSchema>): Promise<{
+    documentId: string;
+    index: number;
+    _apiMs: number;
+}>;

package/dist/tools/insert-page-break.js

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

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const InsertTableSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    rows: z.ZodNumber;
+    columns: z.ZodNumber;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export declare function insertTable(args: z.infer<typeof InsertTableSchema>): Promise<{
+    documentId: string;
+    rows: number;
+    columns: number;
+    index: number;
+    _apiMs: number;
+}>;

package/dist/tools/insert-table.js

@@ -0,0 +1,36 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+export const InsertTableSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    rows: z.number().min(1).max(20).describe('Number of rows (1-20)'),
+    columns: z.number().min(1).max(20).describe('Number of columns (1-20)'),
+    index: z.number().describe('Position in the document to insert the table'),
+});
+export async function insertTable(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const apiStart = performance.now();
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: {
+            requests: [
+                {
+                    insertTable: {
+                        location: { index: args.index },
+                        rows: args.rows,
+                        columns: args.columns,
+                    },
+                },
+            ],
+        },
+    });
+    const apiMs = Math.round(performance.now() - apiStart);
+    return {
+        documentId: args.documentId,
+        rows: args.rows,
+        columns: args.columns,
+        index: args.index,
+        _apiMs: apiMs,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdocs-mcp",
-  "version": "0.3.0",
+  "version": "0.4.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",