gogcli-mcp-docs 1.0.6

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "gogcli-mcp-docs",
+  "version": "1.0.6",
+  "description": "Extended Google Docs MCP server via gogcli — all base tools plus full Docs support",
+  "type": "module",
+  "bin": {
+    "gogcli-mcp-docs": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && npm run bundle",
+    "bundle": "node ../../scripts/bundle.js src/index.ts dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "gogcli-mcp": "*",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "license": "MIT"
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createBaseServer } from 'gogcli-mcp/lib';
+import { registerExtraDocsTools } from './tools/docs-extra.js';
+
+const server = createBaseServer({ name: 'gogcli-docs' });
+registerExtraDocsTools(server);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/tools/docs-extra.ts

@@ -0,0 +1,227 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { accountParam, runOrDiagnose } from 'gogcli-mcp/lib';
+
+export function registerExtraDocsTools(server: McpServer): void {
+  server.registerTool('gog_docs_copy', {
+    description: 'Copy a Google Doc to a new document with the given title.',
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      title: z.string().describe('Title for the new copy'),
+      parent: z.string().optional().describe('Parent folder ID to place the copy in'),
+      account: accountParam,
+    },
+  }, async ({ docId, title, parent, account }) => {
+    const args = ['docs', 'copy', docId, title];
+    if (parent) args.push(`--parent=${parent}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_delete', {
+    description: 'Delete content within a Google Doc by character index range.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      start: z.number().describe('Start index (character position, 1-based)'),
+      end: z.number().describe('End index (character position, exclusive)'),
+      tabId: z.string().optional().describe('Tab ID to delete content from (for multi-tab docs)'),
+      account: accountParam,
+    },
+  }, async ({ docId, start, end, tabId, account }) => {
+    const args = ['docs', 'delete', `--start=${start}`, `--end=${end}`, docId];
+    if (tabId) args.push(`--tab-id=${tabId}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_edit', {
+    description: 'Edit a Google Doc by finding and replacing text (stream-edit style).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      find: z.string().describe('Text to find'),
+      replace: z.string().describe('Replacement text'),
+      matchCase: z.boolean().optional().describe('Case-sensitive matching'),
+      account: accountParam,
+    },
+  }, async ({ docId, find, replace, matchCase, account }) => {
+    const args = ['docs', 'edit', docId, find, replace];
+    if (matchCase) args.push('--match-case');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_export', {
+    description: 'Export a Google Doc as PDF, plain text, HTML, DOCX, or other format.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      format: z.string().optional().describe('Export format: pdf, txt, html, docx, rtf, odt, epub (default: pdf)'),
+      out: z.string().optional().describe('Output file path'),
+      account: accountParam,
+    },
+  }, async ({ docId, format, out, account }) => {
+    const args = ['docs', 'export', docId];
+    if (format) args.push(`--format=${format}`);
+    if (out) args.push(`--out=${out}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_insert', {
+    description: 'Insert text at a specific position in a Google Doc.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      content: z.string().optional().describe('Text content to insert'),
+      index: z.number().optional().describe('Character index to insert at (default: end of document)'),
+      file: z.string().optional().describe('Path to a file whose content to insert'),
+      tabId: z.string().optional().describe('Tab ID to insert into (for multi-tab docs)'),
+      account: accountParam,
+    },
+  }, async ({ docId, content, index, file, tabId, account }) => {
+    const args = ['docs', 'insert', docId];
+    if (content) args.push(content);
+    if (index !== undefined) args.push(`--index=${index}`);
+    if (file) args.push(`--file=${file}`);
+    if (tabId) args.push(`--tab-id=${tabId}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_list_tabs', {
+    description: 'List all tabs in a Google Doc.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      account: accountParam,
+    },
+  }, async ({ docId, account }) => {
+    return runOrDiagnose(['docs', 'list-tabs', docId], { account });
+  });
+
+  server.registerTool('gog_docs_sed', {
+    description: 'Stream-edit a Google Doc with sed-like regex expressions (s/find/replace/ syntax).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      expression: z.string().optional().describe('Single sed expression (e.g. "s/old/new/g")'),
+      expressions: z.array(z.string()).optional().describe('Multiple sed expressions'),
+      file: z.string().optional().describe('Path to a sed script file'),
+      tab: z.string().optional().describe('Tab name to edit'),
+      account: accountParam,
+    },
+  }, async ({ docId, expression, expressions, file, tab, account }) => {
+    const args = ['docs', 'sed', docId];
+    if (expression) args.push(expression);
+    if (expressions) {
+      for (const expr of expressions) {
+        args.push(`--expressions=${expr}`);
+      }
+    }
+    if (file) args.push(`--file=${file}`);
+    if (tab) args.push(`--tab=${tab}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_update', {
+    description: 'Update a Google Doc — insert or replace text at a specific position.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      text: z.string().optional().describe('Text content to write'),
+      file: z.string().optional().describe('Path to a file whose content to use'),
+      index: z.number().optional().describe('Character index to insert at'),
+      tabId: z.string().optional().describe('Tab ID for multi-tab docs'),
+      pageless: z.boolean().optional().describe('Set document to pageless format'),
+      account: accountParam,
+    },
+  }, async ({ docId, text, file, index, tabId, pageless, account }) => {
+    const args = ['docs', 'update', docId];
+    if (text) args.push(`--text=${text}`);
+    if (file) args.push(`--file=${file}`);
+    if (index !== undefined) args.push(`--index=${index}`);
+    if (tabId) args.push(`--tab-id=${tabId}`);
+    if (pageless) args.push('--pageless');
+    return runOrDiagnose(args, { account });
+  });
+
+  // --- Dedicated comment tools (replacing the generic escape hatch in base) ---
+
+  server.registerTool('gog_docs_comments_list', {
+    description:
+      'List comments on a Google Doc. Returns open comments by default; set includeResolved=true to include resolved comments.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      includeResolved: z.boolean().optional().describe('Include resolved comments (default: false, open only)'),
+      account: accountParam,
+    },
+  }, async ({ docId, includeResolved, account }) => {
+    const args = ['docs', 'comments', 'list', docId];
+    if (includeResolved) args.push('--include-resolved');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_comments_get', {
+    description: 'Get a single comment by ID, including its replies.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      commentId: z.string().describe('Comment ID'),
+      account: accountParam,
+    },
+  }, async ({ docId, commentId, account }) => {
+    return runOrDiagnose(['docs', 'comments', 'get', docId, commentId], { account });
+  });
+
+  server.registerTool('gog_docs_comments_add', {
+    description:
+      'Add a comment to a Google Doc. Optionally attach quoted text that appears as the highlighted passage in the Google Docs UI.',
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      content: z.string().describe('Comment text'),
+      quoted: z.string().optional().describe('Quoted text to attach to the comment (shown in UIs when available)'),
+      account: accountParam,
+    },
+  }, async ({ docId, content, quoted, account }) => {
+    const args = ['docs', 'comments', 'add', docId, content];
+    if (quoted) args.push(`--quoted=${quoted}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_comments_reply', {
+    description: 'Reply to an existing comment on a Google Doc.',
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      commentId: z.string().describe('Comment ID to reply to'),
+      content: z.string().describe('Reply text'),
+      account: accountParam,
+    },
+  }, async ({ docId, commentId, content, account }) => {
+    return runOrDiagnose(['docs', 'comments', 'reply', docId, commentId, content], { account });
+  });
+
+  server.registerTool('gog_docs_comments_resolve', {
+    description: 'Resolve a comment (mark as done). Optionally include a closing message.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      commentId: z.string().describe('Comment ID to resolve'),
+      message: z.string().optional().describe('Optional message to include when resolving'),
+      account: accountParam,
+    },
+  }, async ({ docId, commentId, message, account }) => {
+    const args = ['docs', 'comments', 'resolve', docId, commentId];
+    if (message) args.push(`--message=${message}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_docs_comments_delete', {
+    description: 'Delete a comment from a Google Doc. This action is permanent.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: z.string().describe('Doc ID (from the URL)'),
+      commentId: z.string().describe('Comment ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ docId, commentId, account }) => {
+    return runOrDiagnose(['docs', 'comments', 'delete', docId, commentId], { account });
+  });
+}

package/tests/tools/docs-extra.test.ts

@@ -0,0 +1,653 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+vi.mock('gogcli-mcp/lib', async () => {
+  const { z } = await import('zod');
+  const mockRun = vi.fn<(args: string[], options?: { account?: string }) => Promise<string>>();
+  const accountParam = z.string().optional().describe('Google account email');
+  const toText = (output: string) => ({ content: [{ type: 'text' as const, text: output }] });
+  const toError = (err: unknown) =>
+    toText(err instanceof Error ? `Error: ${err.message}` : String(err));
+
+  return {
+    createBaseServer: vi.fn(),
+    run: mockRun,
+    accountParam,
+    toText,
+    toError,
+    runOrDiagnose: async (args: string[], options: { account?: string }) => {
+      try {
+        return toText(await mockRun(args, options));
+      } catch (err) {
+        return toError(err);
+      }
+    },
+  };
+});
+
+import { run } from 'gogcli-mcp/lib';
+import { registerExtraDocsTools } from '../../src/tools/docs-extra.js';
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+function setupHandlers(): Map<string, ToolHandler> {
+  const server = new McpServer({ name: 'test', version: '0.0.0' });
+  const handlers = new Map<string, ToolHandler>();
+  vi.spyOn(server, 'registerTool').mockImplementation((name, _config, cb) => {
+    handlers.set(name, cb as ToolHandler);
+    return undefined as never;
+  });
+  registerExtraDocsTools(server);
+  return handlers;
+}
+
+beforeEach(() => vi.clearAllMocks());
+
+// --- gog_docs_copy ---
+
+describe('gog_docs_copy', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{"docId":"newid"}');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_copy')!({ docId: 'abc', title: 'My Copy' });
+    expect(run).toHaveBeenCalledWith(['docs', 'copy', 'abc', 'My Copy'], { account: undefined });
+    expect(result.content[0].text).toContain('newid');
+  });
+
+  it('includes --parent when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_copy')!({ docId: 'abc', title: 'Copy', parent: 'folder123' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'copy', 'abc', 'Copy', '--parent=folder123'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --parent when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_copy')!({ docId: 'abc', title: 'Copy' });
+    expect(run).toHaveBeenCalledWith(['docs', 'copy', 'abc', 'Copy'], { account: undefined });
+  });
+
+  it('forwards account override', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_copy')!({ docId: 'abc', title: 'Copy', account: 'other@gmail.com' });
+    expect(run).toHaveBeenCalledWith(['docs', 'copy', 'abc', 'Copy'], { account: 'other@gmail.com' });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Copy failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_copy')!({ docId: 'bad', title: 'x' });
+    expect(result.content[0].text).toBe('Error: Copy failed');
+  });
+});
+
+// --- gog_docs_delete ---
+
+describe('gog_docs_delete', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_delete')!({ docId: 'abc', start: 5, end: 10 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'delete', '--start=5', '--end=10', 'abc'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --tab-id when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_delete')!({ docId: 'abc', start: 1, end: 5, tabId: 'tab1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'delete', '--start=1', '--end=5', 'abc', '--tab-id=tab1'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --tab-id when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_delete')!({ docId: 'abc', start: 1, end: 5 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'delete', '--start=1', '--end=5', 'abc'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Delete failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_delete')!({ docId: 'bad', start: 1, end: 5 });
+    expect(result.content[0].text).toBe('Error: Delete failed');
+  });
+});
+
+// --- gog_docs_edit ---
+
+describe('gog_docs_edit', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_edit')!({ docId: 'abc', find: 'old', replace: 'new' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'edit', 'abc', 'old', 'new'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --match-case when true', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_edit')!({ docId: 'abc', find: 'old', replace: 'new', matchCase: true });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'edit', 'abc', 'old', 'new', '--match-case'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --match-case when false', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_edit')!({ docId: 'abc', find: 'old', replace: 'new', matchCase: false });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'edit', 'abc', 'old', 'new'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Edit failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_edit')!({ docId: 'bad', find: 'x', replace: 'y' });
+    expect(result.content[0].text).toBe('Error: Edit failed');
+  });
+});
+
+// --- gog_docs_export ---
+
+describe('gog_docs_export', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('Exported to file.pdf');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_export')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'export', 'abc'], { account: undefined });
+    expect(result.content[0].text).toContain('Exported');
+  });
+
+  it('includes --format when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_export')!({ docId: 'abc', format: 'html' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'export', 'abc', '--format=html'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --out when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_export')!({ docId: 'abc', out: '/tmp/doc.pdf' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'export', 'abc', '--out=/tmp/doc.pdf'],
+      { account: undefined },
+    );
+  });
+
+  it('includes both --format and --out when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_export')!({ docId: 'abc', format: 'txt', out: '/tmp/doc.txt' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'export', 'abc', '--format=txt', '--out=/tmp/doc.txt'],
+      { account: undefined },
+    );
+  });
+
+  it('omits optional flags when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_export')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'export', 'abc'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Export failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_export')!({ docId: 'bad' });
+    expect(result.content[0].text).toBe('Error: Export failed');
+  });
+});
+
+// --- gog_docs_insert ---
+
+describe('gog_docs_insert', () => {
+  it('calls run with content', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc', content: 'Hello world' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'insert', 'abc', 'Hello world'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --index when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc', content: 'text', index: 5 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'insert', 'abc', 'text', '--index=5'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --index=0 when index is zero', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc', content: 'text', index: 0 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'insert', 'abc', 'text', '--index=0'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --file when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc', file: '/tmp/text.txt' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'insert', 'abc', '--file=/tmp/text.txt'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --tab-id when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc', content: 'hi', tabId: 'tab1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'insert', 'abc', 'hi', '--tab-id=tab1'],
+      { account: undefined },
+    );
+  });
+
+  it('omits optional flags when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_insert')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'insert', 'abc'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Insert failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_insert')!({ docId: 'bad' });
+    expect(result.content[0].text).toBe('Error: Insert failed');
+  });
+});
+
+// --- gog_docs_list_tabs ---
+
+describe('gog_docs_list_tabs', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('[{"id":"t1","title":"Tab 1"}]');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_list_tabs')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'list-tabs', 'abc'], { account: undefined });
+    expect(result.content[0].text).toContain('Tab 1');
+  });
+
+  it('forwards account override', async () => {
+    vi.mocked(run).mockResolvedValue('[]');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_list_tabs')!({ docId: 'abc', account: 'other@gmail.com' });
+    expect(run).toHaveBeenCalledWith(['docs', 'list-tabs', 'abc'], { account: 'other@gmail.com' });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('List tabs failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_list_tabs')!({ docId: 'bad' });
+    expect(result.content[0].text).toBe('Error: List tabs failed');
+  });
+});
+
+// --- gog_docs_sed ---
+
+describe('gog_docs_sed', () => {
+  it('calls run with single expression', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_sed')!({ docId: 'abc', expression: 's/old/new/g' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'sed', 'abc', 's/old/new/g'],
+      { account: undefined },
+    );
+  });
+
+  it('calls run with multiple expressions', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_sed')!({
+      docId: 'abc',
+      expressions: ['s/foo/bar/g', 's/baz/qux/g'],
+    });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'sed', 'abc', '--expressions=s/foo/bar/g', '--expressions=s/baz/qux/g'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --file when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_sed')!({ docId: 'abc', file: '/tmp/sed.txt' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'sed', 'abc', '--file=/tmp/sed.txt'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --tab when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_sed')!({ docId: 'abc', expression: 's/a/b/', tab: 'Notes' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'sed', 'abc', 's/a/b/', '--tab=Notes'],
+      { account: undefined },
+    );
+  });
+
+  it('omits optional flags when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_sed')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'sed', 'abc'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Sed failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_sed')!({ docId: 'bad' });
+    expect(result.content[0].text).toBe('Error: Sed failed');
+  });
+});
+
+// --- gog_docs_update ---
+
+describe('gog_docs_update', () => {
+  it('calls run with --text flag', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', text: 'Hello' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--text=Hello'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --file when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', file: '/tmp/content.txt' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--file=/tmp/content.txt'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --index when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', text: 'hi', index: 10 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--text=hi', '--index=10'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --index=0 when index is zero', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', text: 'hi', index: 0 });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--text=hi', '--index=0'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --tab-id when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', text: 'hi', tabId: 'tab1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--text=hi', '--tab-id=tab1'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --pageless when true', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', pageless: true });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc', '--pageless'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --pageless when false', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc', pageless: false });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'update', 'abc'],
+      { account: undefined },
+    );
+  });
+
+  it('omits optional flags when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_update')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'update', 'abc'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Update failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_update')!({ docId: 'bad' });
+    expect(result.content[0].text).toBe('Error: Update failed');
+  });
+});
+
+// --- Dedicated comment tools ---
+
+describe('gog_docs_comments_list', () => {
+  it('calls run with correct args for open comments', async () => {
+    vi.mocked(run).mockResolvedValue('[{"id":"c1","content":"Fix this"}]');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_list')!({ docId: 'abc' });
+    expect(run).toHaveBeenCalledWith(['docs', 'comments', 'list', 'abc'], { account: undefined });
+    expect(result.content[0].text).toContain('Fix this');
+  });
+
+  it('includes --include-resolved when set', async () => {
+    vi.mocked(run).mockResolvedValue('[]');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_list')!({ docId: 'abc', includeResolved: true });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'list', 'abc', '--include-resolved'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --include-resolved when false', async () => {
+    vi.mocked(run).mockResolvedValue('[]');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_list')!({ docId: 'abc', includeResolved: false });
+    expect(run).toHaveBeenCalledWith(['docs', 'comments', 'list', 'abc'], { account: undefined });
+  });
+
+  it('forwards account override', async () => {
+    vi.mocked(run).mockResolvedValue('[]');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_list')!({ docId: 'abc', account: 'other@gmail.com' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'list', 'abc'],
+      { account: 'other@gmail.com' },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('List failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_list')!({ docId: 'bad' });
+    expect(result.content[0].text).toContain('Error: List failed');
+  });
+});
+
+describe('gog_docs_comments_get', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{"id":"c1","content":"Fix this","replies":[]}');
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_get')!({ docId: 'abc', commentId: 'c1' });
+    expect(run).toHaveBeenCalledWith(['docs', 'comments', 'get', 'abc', 'c1'], { account: undefined });
+    expect(result.content[0].text).toContain('Fix this');
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Not found'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_get')!({ docId: 'abc', commentId: 'bad' });
+    expect(result.content[0].text).toContain('Error: Not found');
+  });
+});
+
+describe('gog_docs_comments_add', () => {
+  it('calls run with content', async () => {
+    vi.mocked(run).mockResolvedValue('{"id":"c2"}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_add')!({ docId: 'abc', content: 'Please review' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'add', 'abc', 'Please review'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --quoted when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{"id":"c2"}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_add')!({
+      docId: 'abc', content: 'Typo here', quoted: 'teh',
+    });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'add', 'abc', 'Typo here', '--quoted=teh'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --quoted when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{"id":"c2"}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_add')!({ docId: 'abc', content: 'Nice' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'add', 'abc', 'Nice'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Add failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_add')!({ docId: 'bad', content: 'x' });
+    expect(result.content[0].text).toContain('Error: Add failed');
+  });
+});
+
+describe('gog_docs_comments_reply', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{"id":"r1"}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_reply')!({ docId: 'abc', commentId: 'c1', content: 'Done' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'reply', 'abc', 'c1', 'Done'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Reply failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_reply')!({
+      docId: 'abc', commentId: 'c1', content: 'x',
+    });
+    expect(result.content[0].text).toContain('Error: Reply failed');
+  });
+});
+
+describe('gog_docs_comments_resolve', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_resolve')!({ docId: 'abc', commentId: 'c1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'resolve', 'abc', 'c1'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --message when provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_resolve')!({
+      docId: 'abc', commentId: 'c1', message: 'Fixed in v2',
+    });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'resolve', 'abc', 'c1', '--message=Fixed in v2'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --message when not provided', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_resolve')!({ docId: 'abc', commentId: 'c1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'resolve', 'abc', 'c1'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Resolve failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_resolve')!({ docId: 'abc', commentId: 'c1' });
+    expect(result.content[0].text).toContain('Error: Resolve failed');
+  });
+});
+
+describe('gog_docs_comments_delete', () => {
+  it('calls run with correct args', async () => {
+    vi.mocked(run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_docs_comments_delete')!({ docId: 'abc', commentId: 'c1' });
+    expect(run).toHaveBeenCalledWith(
+      ['docs', 'comments', 'delete', 'abc', 'c1'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(run).mockRejectedValue(new Error('Delete failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_docs_comments_delete')!({ docId: 'abc', commentId: 'c1' });
+    expect(result.content[0].text).toContain('Error: Delete failed');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../gogcli-mcp" }]
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/index.ts'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+    },
+  },
+});