gogcli-mcp-calendar 2.0.6

package/manifest.json

@@ -0,0 +1,140 @@
+{
+  "$schema": "https://raw.githubusercontent.com/anthropics/dxt/main/dist/mcpb-manifest.schema.json",
+  "manifest_version": "0.3",
+  "name": "gogcli-mcp-calendar",
+  "display_name": "gogcli (Calendar)",
+  "version": "2.0.6",
+  "description": "Extended Google Calendar for Claude via gogcli — auth + Calendar events + Meet space management",
+  "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",
+    "calendar",
+    "meet",
+    "meetings",
+    "gogcli",
+    "gog"
+  ],
+  "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"
+    },
+    {
+      "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_calendar_events",
+      "description": "List calendar events with optional filters"
+    },
+    {
+      "name": "gog_calendar_get",
+      "description": "Get a specific calendar event"
+    },
+    {
+      "name": "gog_calendar_create",
+      "description": "Create a calendar event"
+    },
+    {
+      "name": "gog_calendar_update",
+      "description": "Update an existing calendar event"
+    },
+    {
+      "name": "gog_calendar_delete",
+      "description": "Delete a calendar event"
+    },
+    {
+      "name": "gog_calendar_respond",
+      "description": "Respond to a calendar event invitation"
+    },
+    {
+      "name": "gog_calendar_run",
+      "description": "Run any gog calendar subcommand (escape hatch)"
+    },
+    {
+      "name": "gog_meet_create",
+      "description": "Create a Google Meet space"
+    },
+    {
+      "name": "gog_meet_get",
+      "description": "Get a Google Meet space by meeting code"
+    },
+    {
+      "name": "gog_meet_update",
+      "description": "Update a Google Meet space configuration"
+    },
+    {
+      "name": "gog_meet_end",
+      "description": "End the active conference in a Meet space"
+    },
+    {
+      "name": "gog_meet_history",
+      "description": "List past calls in a Meet space"
+    },
+    {
+      "name": "gog_meet_participants",
+      "description": "List participants from a Meet call"
+    }
+  ],
+  "compatibility": {
+    "platforms": [
+      "darwin",
+      "linux",
+      "win32"
+    ],
+    "runtimes": {
+      "node": ">=18.0.0"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "gogcli-mcp-calendar",
+  "version": "2.0.6",
+  "mcpName": "io.github.chrischall/gogcli-mcp-calendar",
+  "description": "Extended Google Calendar + Meet MCP server via gogcli — auth + Calendar events + Meet space management",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chrischall/gogcli-mcp"
+  },
+  "type": "module",
+  "bin": {
+    "gogcli-mcp-calendar": "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.4.3"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "google",
+    "gogcli",
+    "calendar",
+    "meet",
+    "meetings"
+  ]
+}

package/src/index.ts

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

package/src/tools/calendar-extra.ts

@@ -0,0 +1,99 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { accountParam, runOrDiagnose } from '../../../gogcli-mcp/src/lib.js';
+
+const meetAccess = z.enum(['open', 'trusted', 'restricted']);
+
+export function registerExtraCalendarTools(server: McpServer): void {
+  // ─── Meet API tools ────────────────────────────────────────────
+  // Meet spaces are the conferencing surface attached to calendar events,
+  // so they live in the calendar sub-package.
+
+  server.registerTool('gog_meet_create', {
+    description: 'Create a Google Meet space and return its meeting code.',
+    inputSchema: {
+      access: meetAccess.optional().describe('Access type (default: trusted)'),
+      open: z.boolean().optional().describe('Open the meeting in a browser after creation'),
+      account: accountParam,
+    },
+  }, async ({ access, open, account }) => {
+    const args = ['meet', 'create'];
+    if (access) args.push(`--access=${access}`);
+    if (open) args.push('--open');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_meet_get', {
+    description: 'Get a Google Meet space by its meeting code.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      meetingCode: z.string().describe('Meeting code (e.g. abc-defg-hij)'),
+      account: accountParam,
+    },
+  }, async ({ meetingCode, account }) => {
+    return runOrDiagnose(['meet', 'get', meetingCode], { account });
+  });
+
+  server.registerTool('gog_meet_update', {
+    description: 'Update a Google Meet space configuration.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      meetingCode: z.string().describe('Meeting code'),
+      access: meetAccess.optional().describe('Access type'),
+      account: accountParam,
+    },
+  }, async ({ meetingCode, access, account }) => {
+    const args = ['meet', 'update', meetingCode];
+    if (access) args.push(`--access=${access}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_meet_end', {
+    description: 'End the active conference in a Google Meet space.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      meetingCode: z.string().describe('Meeting code'),
+      account: accountParam,
+    },
+  }, async ({ meetingCode, account }) => {
+    return runOrDiagnose(['meet', 'end', meetingCode], { account });
+  });
+
+  server.registerTool('gog_meet_history', {
+    description: 'List past calls (conferences) in a Google Meet space.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      meetingCode: z.string().describe('Meeting code'),
+      max: z.number().optional().describe('Max results (default: 20)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      account: accountParam,
+    },
+  }, async ({ meetingCode, max, page, all, account }) => {
+    const args = ['meet', 'history', meetingCode];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_meet_participants', {
+    description: 'List participants from the latest (or a specific) Meet call.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      meetingCode: z.string().describe('Meeting code'),
+      conference: z.string().optional().describe('Specific conference ID (default: most recent)'),
+      max: z.number().optional().describe('Max results (default: 50)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      account: accountParam,
+    },
+  }, async ({ meetingCode, conference, max, page, all, account }) => {
+    const args = ['meet', 'participants', meetingCode];
+    if (conference) args.push(`--conference=${conference}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    return runOrDiagnose(args, { account });
+  });
+}

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

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerExtraCalendarTools } from '../../src/tools/calendar-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+import { setupExtrasHandlers, toText, type ToolHandler } from '../../../gogcli-mcp/tests/helpers/extras-harness.js';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return {
+    ...actual,
+    runOrDiagnose: vi.fn(),
+  };
+});
+
+let handlers: Map<string, ToolHandler>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+  handlers = setupExtrasHandlers(registerExtraCalendarTools);
+});
+
+describe('gog_meet_create', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_meet_create')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'create'], { account: undefined });
+  });
+
+  it('passes --access and --open when provided', async () => {
+    await handlers.get('gog_meet_create')!({ access: 'open', open: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['meet', 'create', '--access=open', '--open'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --open when false', async () => {
+    await handlers.get('gog_meet_create')!({ open: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'create'], { account: undefined });
+  });
+});
+
+describe('gog_meet_get', () => {
+  it('calls runOrDiagnose with meetingCode', async () => {
+    await handlers.get('gog_meet_get')!({ meetingCode: 'abc-defg-hij' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'get', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_update', () => {
+  it('calls runOrDiagnose with meetingCode and --access', async () => {
+    await handlers.get('gog_meet_update')!({ meetingCode: 'abc-defg-hij', access: 'restricted' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['meet', 'update', 'abc-defg-hij', '--access=restricted'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --access when not provided', async () => {
+    await handlers.get('gog_meet_update')!({ meetingCode: 'abc-defg-hij' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'update', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_end', () => {
+  it('calls runOrDiagnose with meetingCode', async () => {
+    await handlers.get('gog_meet_end')!({ meetingCode: 'abc-defg-hij' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'end', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_history', () => {
+  it('calls runOrDiagnose with meetingCode', async () => {
+    await handlers.get('gog_meet_history')!({ meetingCode: 'abc-defg-hij' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'history', 'abc-defg-hij'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    await handlers.get('gog_meet_history')!({
+      meetingCode: 'abc-defg-hij',
+      max: 50,
+      page: 'tok',
+      all: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['meet', 'history', 'abc-defg-hij', '--max=50', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_meet_history')!({ meetingCode: 'abc-defg-hij', all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['meet', 'history', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_participants', () => {
+  it('calls runOrDiagnose with meetingCode', async () => {
+    await handlers.get('gog_meet_participants')!({ meetingCode: 'abc-defg-hij' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['meet', 'participants', 'abc-defg-hij'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --conference and pagination flags', async () => {
+    await handlers.get('gog_meet_participants')!({
+      meetingCode: 'abc-defg-hij',
+      conference: 'conf123',
+      max: 100,
+      page: 'tok',
+      all: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'meet', 'participants', 'abc-defg-hij',
+        '--conference=conf123',
+        '--max=100',
+        '--page=tok',
+        '--all',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_meet_participants')!({ meetingCode: 'abc-defg-hij', all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['meet', 'participants', 'abc-defg-hij'],
+      { 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,
+      },
+    },
+  },
+});