gogcli-mcp 2.0.2 → 2.0.4

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp",
   "display_name": "gogcli",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",
@@ -120,6 +120,30 @@
       "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"
+    },
     {
       "name": "gog_classroom_courses_list",
       "description": "List Google Classroom courses"
@@ -380,6 +404,26 @@
       "name": "gog_contacts_run",
       "description": "Run any gog contacts subcommand (escape hatch)"
     },
+    {
+      "name": "gog_people_me",
+      "description": "Show your own Google People profile"
+    },
+    {
+      "name": "gog_people_get",
+      "description": "Get a People profile by resource name"
+    },
+    {
+      "name": "gog_people_search",
+      "description": "Search the Google Workspace directory"
+    },
+    {
+      "name": "gog_people_relations",
+      "description": "Get relations (manager, reports) for a user"
+    },
+    {
+      "name": "gog_people_raw",
+      "description": "Dump raw Google People API JSON for a person"
+    },
     {
       "name": "gog_docs_info",
       "description": "Get Google Doc metadata (title, ID, properties)"

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "gogcli-mcp",
-  "version": "2.0.2",
+  "version": "2.0.4",
+  "mcpName": "io.github.chrischall/gogcli-mcp",
   "description": "MCP server wrapping gogcli for Google service access",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
   "repository": {
@@ -41,10 +42,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.2",
     "@vitest/coverage-v8": "^4.1.2",
     "esbuild": "^0.28.0",
     "typescript": "^6.0.2",

package/server.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.chrischall/gogcli-mcp",
+  "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
+  "repository": {
+    "url": "https://github.com/chrischall/gogcli-mcp",
+    "source": "github",
+    "subfolder": "packages/gogcli-mcp"
+  },
+  "version": "2.0.4",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "gogcli-mcp",
+      "version": "2.0.4",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "GOG_ACCOUNT",
+          "description": "Email address of the Google account to use (matches gogcli auth)",
+          "isRequired": false,
+          "format": "string"
+        },
+        {
+          "name": "GOG_PATH",
+          "description": "Override path to the gogcli binary (auto-discovered otherwise)",
+          "isRequired": false,
+          "format": "string"
+        }
+      ]
+    }
+  ]
+}

package/src/tools/calendar.ts

@@ -125,4 +125,96 @@ export function registerCalendarTools(server: McpServer): void {
   }, async ({ subcommand, args, account }) => {
     return runOrDiagnose(['calendar', subcommand, ...args], { account });
   });
+
+  // ─── Meet API tools ────────────────────────────────────────────
+  // Folded into the calendar wrapper because Meet spaces are the
+  // conferencing surface attached to calendar events.
+
+  server.registerTool('gog_meet_create', {
+    description: 'Create a Google Meet space and return its meeting code.',
+    inputSchema: {
+      access: z.enum(['open', 'trusted', 'restricted']).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: z.enum(['open', 'trusted', 'restricted']).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/src/tools/contacts.ts

@@ -68,4 +68,78 @@ export function registerContactsTools(server: McpServer): void {
   }, async ({ subcommand, args, account }) => {
     return runOrDiagnose(['contacts', subcommand, ...args], { account });
   });
+
+  // ─── People API tools ──────────────────────────────────────────
+  // Folded into the contacts wrapper because People is the richer API behind
+  // Google Contacts (Workspace directory search, profile fields, relations).
+
+  server.registerTool('gog_people_me', {
+    description: 'Show your own People profile (people/me).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam,
+    },
+  }, async ({ account }) => {
+    return runOrDiagnose(['people', 'me'], { account });
+  });
+
+  server.registerTool('gog_people_get', {
+    description: 'Get a People profile by resource name.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      userId: z.string().describe('Person resource name (people/...) or email'),
+      account: accountParam,
+    },
+  }, async ({ userId, account }) => {
+    return runOrDiagnose(['people', 'get', userId], { account });
+  });
+
+  server.registerTool('gog_people_search', {
+    description: 'Search the Google Workspace directory (covers internal users, unlike contacts search which is limited to your personal contacts).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: z.string().describe('Search query (name, email, etc.)'),
+      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 ({ query, max, page, all, account }) => {
+    const args = ['people', 'search', query];
+    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_people_relations', {
+    description: 'Get relations (manager, reports, etc.) for a user. Defaults to self when userId is omitted.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      userId: z.string().optional().describe('Person resource name (defaults to self when omitted)'),
+      type: z.string().optional().describe('Filter to a specific relation type (e.g. "manager")'),
+      account: accountParam,
+    },
+  }, async ({ userId, type, account }) => {
+    const args = ['people', 'relations'];
+    if (userId) args.push(userId);
+    if (type) args.push(`--type=${type}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_people_raw', {
+    description: 'Dump the raw People API response as JSON (lossless; for scripting and LLM consumption).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      userId: z.string().describe('Person resource name (people/...) or email'),
+      personFields: z.string().optional().describe('People API personFields mask (default: broad set)'),
+      pretty: z.boolean().optional().describe('Pretty-print JSON (default: compact single-line)'),
+      account: accountParam,
+    },
+  }, async ({ userId, personFields, pretty, account }) => {
+    const args = ['people', 'raw', userId];
+    if (personFields) args.push(`--person-fields=${personFields}`);
+    if (pretty) args.push('--pretty');
+    return runOrDiagnose(args, { account });
+  });
 }

package/tests/tools/calendar.test.ts

@@ -227,3 +227,141 @@ describe('gog_calendar_run', () => {
     expect(result.content[0].text).toBe('Error: Run failed');
   });
 });
+
+describe('gog_meet_create', () => {
+  it('calls run with no flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_create')!({});
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'create'], { account: undefined });
+  });
+
+  it('passes --access and --open when provided', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_create')!({ access: 'open', open: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['meet', 'create', '--access=open', '--open'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --open when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_create')!({ open: false });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'create'], { account: undefined });
+  });
+});
+
+describe('gog_meet_get', () => {
+  it('calls run with meetingCode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_get')!({ meetingCode: 'abc-defg-hij' });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'get', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_update', () => {
+  it('calls run with meetingCode and --access', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_update')!({ meetingCode: 'abc-defg-hij', access: 'restricted' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['meet', 'update', 'abc-defg-hij', '--access=restricted'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --access when not provided', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_update')!({ meetingCode: 'abc-defg-hij' });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'update', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_end', () => {
+  it('calls run with meetingCode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_end')!({ meetingCode: 'abc-defg-hij' });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'end', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_history', () => {
+  it('calls run with meetingCode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_history')!({ meetingCode: 'abc-defg-hij' });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'history', 'abc-defg-hij'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_history')!({
+      meetingCode: 'abc-defg-hij',
+      max: 50,
+      page: 'tok',
+      all: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['meet', 'history', 'abc-defg-hij', '--max=50', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_history')!({ meetingCode: 'abc-defg-hij', all: false });
+    expect(runner.run).toHaveBeenCalledWith(['meet', 'history', 'abc-defg-hij'], { account: undefined });
+  });
+});
+
+describe('gog_meet_participants', () => {
+  it('calls run with meetingCode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_participants')!({ meetingCode: 'abc-defg-hij' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['meet', 'participants', 'abc-defg-hij'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --conference and pagination flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_participants')!({
+      meetingCode: 'abc-defg-hij',
+      conference: 'conf123',
+      max: 100,
+      page: 'tok',
+      all: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      [
+        'meet', 'participants', 'abc-defg-hij',
+        '--conference=conf123',
+        '--max=100',
+        '--page=tok',
+        '--all',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_meet_participants')!({ meetingCode: 'abc-defg-hij', all: false });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['meet', 'participants', 'abc-defg-hij'],
+      { account: undefined },
+    );
+  });
+});

package/tests/tools/contacts.test.ts

@@ -120,3 +120,103 @@ describe('gog_contacts_run', () => {
     expect(result.content[0].text).toBe('Error: Run failed');
   });
 });
+
+describe('gog_people_me', () => {
+  it('calls run with people me', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"resourceName":"people/me"}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_me')!({});
+    expect(runner.run).toHaveBeenCalledWith(['people', 'me'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Me failed'));
+    const handlers = setupHandlers();
+    const result = await handlers.get('gog_people_me')!({});
+    expect(result.content[0].text).toBe('Error: Me failed');
+  });
+});
+
+describe('gog_people_get', () => {
+  it('calls run with userId', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_get')!({ userId: 'people/c123' });
+    expect(runner.run).toHaveBeenCalledWith(['people', 'get', 'people/c123'], { account: undefined });
+  });
+});
+
+describe('gog_people_search', () => {
+  it('calls run with query', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_search')!({ query: 'alice' });
+    expect(runner.run).toHaveBeenCalledWith(['people', 'search', 'alice'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_search')!({ query: 'alice', max: 100, page: 'tok', all: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['people', 'search', 'alice', '--max=100', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_search')!({ query: 'x', all: false });
+    expect(runner.run).toHaveBeenCalledWith(['people', 'search', 'x'], { account: undefined });
+  });
+});
+
+describe('gog_people_relations', () => {
+  it('calls run with no userId', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_relations')!({});
+    expect(runner.run).toHaveBeenCalledWith(['people', 'relations'], { account: undefined });
+  });
+
+  it('passes userId and --type when provided', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_relations')!({ userId: 'people/c123', type: 'manager' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['people', 'relations', 'people/c123', '--type=manager'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_people_raw', () => {
+  it('calls run with userId', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_raw')!({ userId: 'people/c123' });
+    expect(runner.run).toHaveBeenCalledWith(['people', 'raw', 'people/c123'], { account: undefined });
+  });
+
+  it('passes --person-fields and --pretty when provided', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_raw')!({
+      userId: 'people/c123',
+      personFields: 'names,emailAddresses',
+      pretty: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['people', 'raw', 'people/c123', '--person-fields=names,emailAddresses', '--pretty'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --pretty when false', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const handlers = setupHandlers();
+    await handlers.get('gog_people_raw')!({ userId: 'people/c123', pretty: false });
+    expect(runner.run).toHaveBeenCalledWith(['people', 'raw', 'people/c123'], { account: undefined });
+  });
+});