gogcli-mcp-drive 2.0.0

package/manifest.json

@@ -0,0 +1,179 @@
+{
+  "$schema": "https://raw.githubusercontent.com/anthropics/dxt/main/dist/mcpb-manifest.schema.json",
+  "manifest_version": "0.3",
+  "name": "gogcli-mcp-drive",
+  "display_name": "gogcli (Drive)",
+  "version": "2.0.0",
+  "description": "Extended Google Drive for Claude via gogcli — auth + full Drive support (upload, download, permissions, comments, shared drives)",
+  "author": {
+    "name": "Chris Hall",
+    "email": "chris.c.hall@gmail.com",
+    "url": "https://github.com/chrischall"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chrischall/gogcli-mcp"
+  },
+  "homepage": "https://github.com/chrischall/gogcli-mcp",
+  "support": "https://github.com/chrischall/gogcli-mcp/issues",
+  "license": "MIT",
+  "keywords": [
+    "google",
+    "drive",
+    "gogcli",
+    "gog",
+    "upload",
+    "download",
+    "permissions",
+    "comments",
+    "shared-drives"
+  ],
+  "server": {
+    "type": "node",
+    "entry_point": "dist/index.js",
+    "mcp_config": {
+      "command": "node",
+      "args": [
+        "${__dirname}/dist/index.js"
+      ],
+      "env": {
+        "GOG_ACCOUNT": "${user_config.gog_account}",
+        "GOG_PATH": "${user_config.gog_path}"
+      }
+    }
+  },
+  "user_config": {
+    "gog_account": {
+      "type": "string",
+      "title": "Google Account",
+      "description": "Default Google account email (optional — uses gogcli's configured default if omitted)",
+      "required": false
+    },
+    "gog_path": {
+      "type": "string",
+      "title": "gog Executable Path",
+      "description": "Path to the gog executable (optional — defaults to 'gog' on your PATH)",
+      "required": false
+    }
+  },
+  "tools": [
+    {
+      "name": "gog_auth_add",
+      "description": "Authorize a Google account via browser-based OAuth"
+    },
+    {
+      "name": "gog_auth_list",
+      "description": "List all Google accounts stored in gogcli"
+    },
+    {
+      "name": "gog_auth_status",
+      "description": "Show gogcli auth configuration (keyring, credential files)"
+    },
+    {
+      "name": "gog_auth_services",
+      "description": "List Google services and OAuth scopes supported by gogcli"
+    },
+    {
+      "name": "gog_auth_run",
+      "description": "Run any gog auth subcommand (escape hatch)"
+    },
+    {
+      "name": "gog_drive_ls",
+      "description": "List files in a Google Drive folder (with pagination and query filters)"
+    },
+    {
+      "name": "gog_drive_search",
+      "description": "Full-text search across Drive"
+    },
+    {
+      "name": "gog_drive_get",
+      "description": "Get file metadata"
+    },
+    {
+      "name": "gog_drive_mkdir",
+      "description": "Create a new folder"
+    },
+    {
+      "name": "gog_drive_rename",
+      "description": "Rename a file or folder"
+    },
+    {
+      "name": "gog_drive_move",
+      "description": "Move a file to a different folder"
+    },
+    {
+      "name": "gog_drive_delete",
+      "description": "Delete a file (trash by default, or permanent=true for irreversible delete)"
+    },
+    {
+      "name": "gog_drive_share",
+      "description": "Share a file or folder"
+    },
+    {
+      "name": "gog_drive_run",
+      "description": "Run any gog drive subcommand (escape hatch)"
+    },
+    {
+      "name": "gog_drive_download",
+      "description": "Download a file (Google Docs formats export as pdf/docx/xlsx/etc.)"
+    },
+    {
+      "name": "gog_drive_upload",
+      "description": "Upload a local file, optionally replacing an existing file or converting to Google format"
+    },
+    {
+      "name": "gog_drive_copy",
+      "description": "Copy a file to a new file"
+    },
+    {
+      "name": "gog_drive_url",
+      "description": "Print shareable web URLs for one or more files"
+    },
+    {
+      "name": "gog_drive_permissions",
+      "description": "List permissions on a file"
+    },
+    {
+      "name": "gog_drive_unshare",
+      "description": "Remove a permission from a file"
+    },
+    {
+      "name": "gog_drive_drives_list",
+      "description": "List shared drives (Team Drives)"
+    },
+    {
+      "name": "gog_drive_comments_list",
+      "description": "List comments on a file"
+    },
+    {
+      "name": "gog_drive_comments_get",
+      "description": "Get a single comment by ID"
+    },
+    {
+      "name": "gog_drive_comments_add",
+      "description": "Add a new comment"
+    },
+    {
+      "name": "gog_drive_comments_update",
+      "description": "Update a comment's text"
+    },
+    {
+      "name": "gog_drive_comments_delete",
+      "description": "Delete a comment"
+    },
+    {
+      "name": "gog_drive_comments_reply",
+      "description": "Reply to an existing comment"
+    }
+  ],
+  "compatibility": {
+    "platforms": [
+      "darwin",
+      "linux",
+      "win32"
+    ],
+    "runtimes": {
+      "node": ">=18.0.0"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "gogcli-mcp-drive",
+  "version": "2.0.0",
+  "description": "Extended Google Drive MCP server via gogcli — auth + full Drive support (upload/download/permissions/comments/shared drives)",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chrischall/gogcli-mcp"
+  },
+  "type": "module",
+  "bin": {
+    "gogcli-mcp-drive": "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": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "google",
+    "gogcli",
+    "google-drive",
+    "drive"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer, registerAuthTools, registerDriveTools } from '../../gogcli-mcp/src/lib.js';
+import { registerExtraDriveTools } from './tools/drive-extra.js';
+
+const server = createServer({ name: 'gogcli-drive' });
+registerAuthTools(server);
+registerDriveTools(server);
+registerExtraDriveTools(server);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/tools/drive-extra.ts

@@ -0,0 +1,190 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { accountParam, runOrDiagnose } from '../../../gogcli-mcp/src/lib.js';
+
+export function registerExtraDriveTools(server: McpServer): void {
+  server.registerTool('gog_drive_download', {
+    description: 'Download a Drive file to the local filesystem. For Google Docs formats, specify an export format (pdf, csv, xlsx, pptx, txt, png, docx, md).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID to download'),
+      out: z.string().optional().describe('Output file path (default: gogcli config dir)'),
+      format: z.string().optional().describe('Export format for Google Docs: pdf, csv, xlsx, pptx, txt, png, docx, md (default: inferred)'),
+      account: accountParam,
+    },
+  }, async ({ fileId, out, format, account }) => {
+    const args = ['drive', 'download', fileId];
+    if (out) args.push(`--out=${out}`);
+    if (format) args.push(`--format=${format}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_upload', {
+    description: 'Upload a local file to Drive. Use --replace to replace the content of an existing file (preserves link/permissions), or --convert to auto-convert to a Google format.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      localPath: z.string().describe('Path to the local file to upload'),
+      name: z.string().optional().describe('Override filename (create) or rename target (replace)'),
+      parent: z.string().optional().describe('Destination folder ID (create only)'),
+      replace: z.string().optional().describe('Replace content of an existing Drive file ID (preserves link/permissions)'),
+      mimeType: z.string().optional().describe('Override MIME type inference'),
+      keepRevisionForever: z.boolean().optional().describe('Keep the new head revision forever (binary files only)'),
+      convert: z.boolean().optional().describe('Auto-convert to native Google format based on file extension (create only)'),
+      convertTo: z.string().optional().describe('Convert to a specific Google format: doc | sheet | slides (create only)'),
+      account: accountParam,
+    },
+  }, async ({ localPath, name, parent, replace, mimeType, keepRevisionForever, convert, convertTo, account }) => {
+    const args = ['drive', 'upload', localPath];
+    if (name) args.push(`--name=${name}`);
+    if (parent) args.push(`--parent=${parent}`);
+    if (replace) args.push(`--replace=${replace}`);
+    if (mimeType) args.push(`--mime-type=${mimeType}`);
+    if (keepRevisionForever) args.push('--keep-revision-forever');
+    if (convert) args.push('--convert');
+    if (convertTo) args.push(`--convert-to=${convertTo}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_copy', {
+    description: 'Copy a Drive file to a new file with the given name.',
+    inputSchema: {
+      fileId: z.string().describe('File ID to copy'),
+      name: z.string().describe('Name for the new copy'),
+      parent: z.string().optional().describe('Destination folder ID'),
+      account: accountParam,
+    },
+  }, async ({ fileId, name, parent, account }) => {
+    const args = ['drive', 'copy', fileId, name];
+    if (parent) args.push(`--parent=${parent}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_url', {
+    description: 'Print shareable web URLs for one or more Drive files.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileIds: z.array(z.string()).min(1).describe('One or more file IDs to get URLs for'),
+      account: accountParam,
+    },
+  }, async ({ fileIds, account }) => {
+    return runOrDiagnose(['drive', 'url', ...fileIds], { account });
+  });
+
+  server.registerTool('gog_drive_permissions', {
+    description: 'List permissions on a Drive file.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      max: z.number().optional().describe('Max results (default: 100)'),
+      page: z.string().optional().describe('Page token'),
+      account: accountParam,
+    },
+  }, async ({ fileId, max, page, account }) => {
+    const args = ['drive', 'permissions', fileId];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_unshare', {
+    description: 'Remove a permission from a Drive file. Get the permissionId from gog_drive_permissions.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      permissionId: z.string().describe('Permission ID to remove'),
+      account: accountParam,
+    },
+  }, async ({ fileId, permissionId, account }) => {
+    return runOrDiagnose(['drive', 'unshare', fileId, permissionId], { account });
+  });
+
+  server.registerTool('gog_drive_drives_list', {
+    description: 'List shared drives (Team Drives) accessible to the account.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      max: z.number().optional().describe('Max results (default: 100, max allowed: 100)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      query: z.string().optional().describe('Search query for filtering shared drives'),
+      account: accountParam,
+    },
+  }, async ({ max, page, all, query, account }) => {
+    const args = ['drive', 'drives'];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    if (query) args.push(`--query=${query}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_comments_list', {
+    description: 'List comments on a Drive file.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      account: accountParam,
+    },
+  }, async ({ fileId, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'list', fileId], { account });
+  });
+
+  server.registerTool('gog_drive_comments_get', {
+    description: 'Get a single comment on a Drive file by ID.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      commentId: z.string().describe('Comment ID'),
+      account: accountParam,
+    },
+  }, async ({ fileId, commentId, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'get', fileId, commentId], { account });
+  });
+
+  server.registerTool('gog_drive_comments_add', {
+    description: 'Add a new comment to a Drive file.',
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      content: z.string().describe('Comment text'),
+      account: accountParam,
+    },
+  }, async ({ fileId, content, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'create', fileId, content], { account });
+  });
+
+  server.registerTool('gog_drive_comments_update', {
+    description: 'Update the text of an existing comment.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      commentId: z.string().describe('Comment ID to update'),
+      content: z.string().describe('New comment text'),
+      account: accountParam,
+    },
+  }, async ({ fileId, commentId, content, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'update', fileId, commentId, content], { account });
+  });
+
+  server.registerTool('gog_drive_comments_delete', {
+    description: 'Delete a comment from a Drive file.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      commentId: z.string().describe('Comment ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ fileId, commentId, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'delete', fileId, commentId], { account });
+  });
+
+  server.registerTool('gog_drive_comments_reply', {
+    description: 'Reply to an existing comment on a Drive file.',
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      commentId: z.string().describe('Comment ID to reply to'),
+      content: z.string().describe('Reply text'),
+      account: accountParam,
+    },
+  }, async ({ fileId, commentId, content, account }) => {
+    return runOrDiagnose(['drive', 'comments', 'reply', fileId, commentId, content], { account });
+  });
+}

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

@@ -0,0 +1,222 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerExtraDriveTools } from '../../src/tools/drive-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return {
+    ...actual,
+    runOrDiagnose: vi.fn(),
+  };
+});
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+function toText(text: string) {
+  return { content: [{ type: 'text', text }] };
+}
+
+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;
+  });
+  registerExtraDriveTools(server);
+  return handlers;
+}
+
+let handlers: Map<string, ToolHandler>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+  handlers = setupHandlers();
+});
+
+describe('gog_drive_download', () => {
+  it('calls runOrDiagnose with fileId only', async () => {
+    await handlers.get('gog_drive_download')!({ fileId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'download', 'f1'], { account: undefined });
+  });
+
+  it('passes --out and --format when provided', async () => {
+    await handlers.get('gog_drive_download')!({ fileId: 'f1', out: '/tmp/file.pdf', format: 'pdf', account: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'download', 'f1', '--out=/tmp/file.pdf', '--format=pdf'],
+      { account: 'a@b.com' },
+    );
+  });
+});
+
+describe('gog_drive_upload', () => {
+  it('calls runOrDiagnose with localPath only', async () => {
+    await handlers.get('gog_drive_upload')!({ localPath: '/tmp/x.txt' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'upload', '/tmp/x.txt'], { account: undefined });
+  });
+
+  it('passes all upload flags', async () => {
+    await handlers.get('gog_drive_upload')!({
+      localPath: '/tmp/x.txt',
+      name: 'renamed.txt',
+      parent: 'folder1',
+      replace: 'file2',
+      mimeType: 'text/plain',
+      keepRevisionForever: true,
+      convert: true,
+      convertTo: 'doc',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'drive', 'upload', '/tmp/x.txt',
+        '--name=renamed.txt',
+        '--parent=folder1',
+        '--replace=file2',
+        '--mime-type=text/plain',
+        '--keep-revision-forever',
+        '--convert',
+        '--convert-to=doc',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_drive_upload')!({ localPath: '/tmp/x.txt', keepRevisionForever: false, convert: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'upload', '/tmp/x.txt'], { account: undefined });
+  });
+});
+
+describe('gog_drive_copy', () => {
+  it('calls runOrDiagnose with fileId and name', async () => {
+    await handlers.get('gog_drive_copy')!({ fileId: 'f1', name: 'Copy' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'copy', 'f1', 'Copy'], { account: undefined });
+  });
+
+  it('passes --parent when provided', async () => {
+    await handlers.get('gog_drive_copy')!({ fileId: 'f1', name: 'Copy', parent: 'folder1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'copy', 'f1', 'Copy', '--parent=folder1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_url', () => {
+  it('calls runOrDiagnose with single fileId', async () => {
+    await handlers.get('gog_drive_url')!({ fileIds: ['f1'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'url', 'f1'], { account: undefined });
+  });
+
+  it('calls runOrDiagnose with multiple fileIds', async () => {
+    await handlers.get('gog_drive_url')!({ fileIds: ['f1', 'f2', 'f3'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'url', 'f1', 'f2', 'f3'], { account: undefined });
+  });
+});
+
+describe('gog_drive_permissions', () => {
+  it('calls runOrDiagnose with fileId', async () => {
+    await handlers.get('gog_drive_permissions')!({ fileId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'permissions', 'f1'], { account: undefined });
+  });
+
+  it('passes --max and --page when provided', async () => {
+    await handlers.get('gog_drive_permissions')!({ fileId: 'f1', max: 50, page: 'tok' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'permissions', 'f1', '--max=50', '--page=tok'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_unshare', () => {
+  it('calls runOrDiagnose with fileId and permissionId', async () => {
+    await handlers.get('gog_drive_unshare')!({ fileId: 'f1', permissionId: 'p1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'unshare', 'f1', 'p1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_drives_list', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_drives_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'drives'], { account: undefined });
+  });
+
+  it('passes all listing flags', async () => {
+    await handlers.get('gog_drive_drives_list')!({ max: 50, page: 'tok', all: true, query: 'engineering' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'drives', '--max=50', '--page=tok', '--all', '--query=engineering'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_drive_drives_list')!({ all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'drives'], { account: undefined });
+  });
+});
+
+describe('gog_drive_comments_list', () => {
+  it('calls runOrDiagnose with fileId', async () => {
+    await handlers.get('gog_drive_comments_list')!({ fileId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'list', 'f1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_comments_get', () => {
+  it('calls runOrDiagnose with fileId and commentId', async () => {
+    await handlers.get('gog_drive_comments_get')!({ fileId: 'f1', commentId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'get', 'f1', 'c1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_comments_add', () => {
+  it('calls runOrDiagnose with fileId and content', async () => {
+    await handlers.get('gog_drive_comments_add')!({ fileId: 'f1', content: 'LGTM' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'create', 'f1', 'LGTM'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_comments_update', () => {
+  it('calls runOrDiagnose with fileId, commentId, and content', async () => {
+    await handlers.get('gog_drive_comments_update')!({ fileId: 'f1', commentId: 'c1', content: 'edited' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'update', 'f1', 'c1', 'edited'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_comments_delete', () => {
+  it('calls runOrDiagnose with fileId and commentId', async () => {
+    await handlers.get('gog_drive_comments_delete')!({ fileId: 'f1', commentId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'delete', 'f1', 'c1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_comments_reply', () => {
+  it('calls runOrDiagnose with fileId, commentId, and content', async () => {
+    await handlers.get('gog_drive_comments_reply')!({ fileId: 'f1', commentId: 'c1', content: 'thanks' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'comments', 'reply', 'f1', 'c1', 'thanks'],
+      { account: undefined },
+    );
+  });
+});

package/tsconfig.json

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

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,
+      },
+    },
+  },
+});