gogcli-mcp-calendar 2.2.0 → 2.3.0

package/dist/index.js

@@ -31361,7 +31361,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.2.0" : "0.0.0";
+var VERSION = true ? "2.3.0" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31465,6 +31465,132 @@ function registerExtraCalendarTools(server2) {
     if (alias) args.push(`--alias=${alias}`);
     return runOrDiagnose(args, {});
   });
+  server2.registerTool("gog_calendar_calendars", {
+    description: "List the calendars in your calendar list (id, summary, access role, primary flag).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      max: external_exports.number().optional().describe("Max results (default: 100)"),
+      page: external_exports.string().optional().describe("Page token"),
+      all: external_exports.boolean().optional().describe("Fetch all pages"),
+      account: accountParam
+    }
+  }, async ({ max, page, all, account }) => {
+    const args = ["calendar", "calendars"];
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push("--all");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_search", {
+    description: "Full-text search for events matching a query string, with optional time filters.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: external_exports.string().describe("Search query"),
+      from: external_exports.string().optional().describe("Start time (RFC3339, date, or relative: now, today, tomorrow, monday)"),
+      to: external_exports.string().optional().describe("End time (RFC3339, date, or relative: now, today, tomorrow, monday)"),
+      today: external_exports.boolean().optional().describe("Today only"),
+      tomorrow: external_exports.boolean().optional().describe("Tomorrow only"),
+      week: external_exports.boolean().optional().describe("This week (uses weekStart, default Mon)"),
+      days: external_exports.number().optional().describe("Next N days"),
+      weekStart: external_exports.string().optional().describe("Week start day for week (sun, mon, ...)"),
+      calendar: external_exports.string().optional().describe("Calendar ID (default: primary)"),
+      max: external_exports.number().optional().describe("Max results (default: 25)"),
+      account: accountParam
+    }
+  }, async ({ query, from, to, today, tomorrow, week, days, weekStart, calendar, max, account }) => {
+    const args = ["calendar", "search", query];
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (today) args.push("--today");
+    if (tomorrow) args.push("--tomorrow");
+    if (week) args.push("--week");
+    if (days !== void 0) args.push(`--days=${days}`);
+    if (weekStart) args.push(`--week-start=${weekStart}`);
+    if (calendar) args.push(`--calendar=${calendar}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_freebusy", {
+    description: "Query free/busy intervals for one or more calendars over a time window.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      from: external_exports.string().describe("Start time (RFC3339, required)"),
+      to: external_exports.string().describe("End time (RFC3339, required)"),
+      calendarIds: external_exports.string().optional().describe("Comma-separated calendar IDs, names, or indices"),
+      all: external_exports.boolean().optional().describe("Query all calendars"),
+      account: accountParam
+    }
+  }, async ({ from, to, calendarIds, all, account }) => {
+    const args = ["calendar", "freebusy"];
+    if (calendarIds) args.push(calendarIds);
+    args.push(`--from=${from}`);
+    args.push(`--to=${to}`);
+    if (all) args.push("--all");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_colors", {
+    description: "Show the available calendar and event color palette (color IDs to hex values).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["calendar", "colors"], { account });
+  });
+  server2.registerTool("gog_calendar_acl", {
+    description: "List the access control list (sharing rules) for a calendar.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      calendarId: external_exports.string().describe("Calendar ID"),
+      max: external_exports.number().optional().describe("Max results (default: 100)"),
+      page: external_exports.string().optional().describe("Page token"),
+      all: external_exports.boolean().optional().describe("Fetch all pages"),
+      account: accountParam
+    }
+  }, async ({ calendarId, max, page, all, account }) => {
+    const args = ["calendar", "acl", calendarId];
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push("--all");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_move", {
+    description: "Move an event from one calendar to another; the destination calendar becomes the organizer.",
+    inputSchema: {
+      calendarId: external_exports.string().describe("Source calendar ID"),
+      eventId: external_exports.string().describe("Event ID"),
+      destinationCalendarId: external_exports.string().describe("Destination calendar ID that becomes the event organizer"),
+      sendUpdates: external_exports.enum(["all", "externalOnly", "none"]).optional().describe("Notification mode (default: none)"),
+      account: accountParam
+    }
+  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account }) => {
+    const args = ["calendar", "move", calendarId, eventId, destinationCalendarId];
+    if (sendUpdates) args.push(`--send-updates=${sendUpdates}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_out_of_office", {
+    description: "Create an Out of Office event that auto-declines invitations during the block.",
+    inputSchema: {
+      from: external_exports.string().describe("Start date or datetime (RFC3339 or YYYY-MM-DD)"),
+      to: external_exports.string().describe("End date or datetime (RFC3339 or YYYY-MM-DD)"),
+      calendarId: external_exports.string().optional().describe("Calendar ID (default: primary)"),
+      summary: external_exports.string().optional().describe('Out of office title (default: "Out of office")'),
+      autoDecline: external_exports.enum(["none", "all", "new"]).optional().describe("Auto-decline mode (default: all)"),
+      declineMessage: external_exports.string().optional().describe("Message for declined invitations"),
+      allDay: external_exports.boolean().optional().describe("Create as an all-day event"),
+      account: accountParam
+    }
+  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account }) => {
+    const args = ["calendar", "out-of-office"];
+    if (calendarId) args.push(calendarId);
+    args.push(`--from=${from}`);
+    args.push(`--to=${to}`);
+    if (summary) args.push(`--summary=${summary}`);
+    if (autoDecline) args.push(`--auto-decline=${autoDecline}`);
+    if (declineMessage) args.push(`--decline-message=${declineMessage}`);
+    if (allDay) args.push("--all-day");
+    return runOrDiagnose(args, { account });
+  });
   server2.registerTool("gog_meet_participants", {
     description: "List participants from the latest (or a specific) Meet call.",
     annotations: { readOnlyHint: true },

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-calendar",
   "display_name": "gogcli (Calendar)",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Extended Google Calendar for Claude via gogcli — auth + Calendar events + Meet space management",
   "author": {
     "name": "Chris Hall",
@@ -102,6 +102,34 @@
       "name": "gog_calendar_run",
       "description": "Run any gog calendar subcommand (escape hatch)"
     },
+    {
+      "name": "gog_calendar_calendars",
+      "description": "List the calendars in your calendar list"
+    },
+    {
+      "name": "gog_calendar_search",
+      "description": "Full-text search for events with optional time filters"
+    },
+    {
+      "name": "gog_calendar_freebusy",
+      "description": "Query free/busy intervals for one or more calendars"
+    },
+    {
+      "name": "gog_calendar_colors",
+      "description": "Show the available calendar and event color palette"
+    },
+    {
+      "name": "gog_calendar_acl",
+      "description": "List the access control list (sharing rules) for a calendar"
+    },
+    {
+      "name": "gog_calendar_move",
+      "description": "Move an event to another calendar"
+    },
+    {
+      "name": "gog_calendar_out_of_office",
+      "description": "Create an Out of Office event that auto-declines invitations"
+    },
     {
       "name": "gog_meet_create",
       "description": "Create a Google Meet space"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-calendar",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "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>",

package/src/tools/calendar-extra.ts

@@ -110,6 +110,141 @@ export function registerExtraCalendarTools(server: McpServer): void {
     return runOrDiagnose(args, {});
   });
 
+  // --- gog 0.19.0 calendar reads & CRUD ---
+
+  server.registerTool('gog_calendar_calendars', {
+    description: 'List the calendars in your calendar list (id, summary, access role, primary flag).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      max: z.number().optional().describe('Max results (default: 100)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      account: accountParam,
+    },
+  }, async ({ max, page, all, account }) => {
+    const args = ['calendar', 'calendars'];
+    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_calendar_search', {
+    description: 'Full-text search for events matching a query string, with optional time filters.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: z.string().describe('Search query'),
+      from: z.string().optional().describe('Start time (RFC3339, date, or relative: now, today, tomorrow, monday)'),
+      to: z.string().optional().describe('End time (RFC3339, date, or relative: now, today, tomorrow, monday)'),
+      today: z.boolean().optional().describe('Today only'),
+      tomorrow: z.boolean().optional().describe('Tomorrow only'),
+      week: z.boolean().optional().describe('This week (uses weekStart, default Mon)'),
+      days: z.number().optional().describe('Next N days'),
+      weekStart: z.string().optional().describe('Week start day for week (sun, mon, ...)'),
+      calendar: z.string().optional().describe('Calendar ID (default: primary)'),
+      max: z.number().optional().describe('Max results (default: 25)'),
+      account: accountParam,
+    },
+  }, async ({ query, from, to, today, tomorrow, week, days, weekStart, calendar, max, account }) => {
+    const args = ['calendar', 'search', query];
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (today) args.push('--today');
+    if (tomorrow) args.push('--tomorrow');
+    if (week) args.push('--week');
+    if (days !== undefined) args.push(`--days=${days}`);
+    if (weekStart) args.push(`--week-start=${weekStart}`);
+    if (calendar) args.push(`--calendar=${calendar}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_calendar_freebusy', {
+    description: 'Query free/busy intervals for one or more calendars over a time window.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      from: z.string().describe('Start time (RFC3339, required)'),
+      to: z.string().describe('End time (RFC3339, required)'),
+      calendarIds: z.string().optional().describe('Comma-separated calendar IDs, names, or indices'),
+      all: z.boolean().optional().describe('Query all calendars'),
+      account: accountParam,
+    },
+  }, async ({ from, to, calendarIds, all, account }) => {
+    const args = ['calendar', 'freebusy'];
+    if (calendarIds) args.push(calendarIds);
+    args.push(`--from=${from}`);
+    args.push(`--to=${to}`);
+    if (all) args.push('--all');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_calendar_colors', {
+    description: 'Show the available calendar and event color palette (color IDs to hex values).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam,
+    },
+  }, async ({ account }) => {
+    return runOrDiagnose(['calendar', 'colors'], { account });
+  });
+
+  server.registerTool('gog_calendar_acl', {
+    description: 'List the access control list (sharing rules) for a calendar.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      calendarId: z.string().describe('Calendar ID'),
+      max: z.number().optional().describe('Max results (default: 100)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      account: accountParam,
+    },
+  }, async ({ calendarId, max, page, all, account }) => {
+    const args = ['calendar', 'acl', calendarId];
+    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_calendar_move', {
+    description: 'Move an event from one calendar to another; the destination calendar becomes the organizer.',
+    inputSchema: {
+      calendarId: z.string().describe('Source calendar ID'),
+      eventId: z.string().describe('Event ID'),
+      destinationCalendarId: z.string().describe('Destination calendar ID that becomes the event organizer'),
+      sendUpdates: z.enum(['all', 'externalOnly', 'none']).optional().describe('Notification mode (default: none)'),
+      account: accountParam,
+    },
+  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account }) => {
+    const args = ['calendar', 'move', calendarId, eventId, destinationCalendarId];
+    if (sendUpdates) args.push(`--send-updates=${sendUpdates}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_calendar_out_of_office', {
+    description: 'Create an Out of Office event that auto-declines invitations during the block.',
+    inputSchema: {
+      from: z.string().describe('Start date or datetime (RFC3339 or YYYY-MM-DD)'),
+      to: z.string().describe('End date or datetime (RFC3339 or YYYY-MM-DD)'),
+      calendarId: z.string().optional().describe('Calendar ID (default: primary)'),
+      summary: z.string().optional().describe('Out of office title (default: "Out of office")'),
+      autoDecline: z.enum(['none', 'all', 'new']).optional().describe('Auto-decline mode (default: all)'),
+      declineMessage: z.string().optional().describe('Message for declined invitations'),
+      allDay: z.boolean().optional().describe('Create as an all-day event'),
+      account: accountParam,
+    },
+  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account }) => {
+    const args = ['calendar', 'out-of-office'];
+    if (calendarId) args.push(calendarId);
+    args.push(`--from=${from}`);
+    args.push(`--to=${to}`);
+    if (summary) args.push(`--summary=${summary}`);
+    if (autoDecline) args.push(`--auto-decline=${autoDecline}`);
+    if (declineMessage) args.push(`--decline-message=${declineMessage}`);
+    if (allDay) args.push('--all-day');
+    return runOrDiagnose(args, { account });
+  });
+
   server.registerTool('gog_meet_participants', {
     description: 'List participants from the latest (or a specific) Meet call.',
     annotations: { readOnlyHint: true },

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

@@ -143,6 +143,183 @@ describe('gog_zoom_auth_doctor', () => {
   });
 });
 
+// --- gog 0.19.0 calendar reads & CRUD ---
+
+describe('gog_calendar_calendars', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_calendar_calendars')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'calendars'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    await handlers.get('gog_calendar_calendars')!({ max: 50, page: 'tok', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'calendars', '--max=50', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_calendar_calendars')!({ all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'calendars'], { account: undefined });
+  });
+});
+
+describe('gog_calendar_search', () => {
+  it('calls runOrDiagnose with just the query', async () => {
+    await handlers.get('gog_calendar_search')!({ query: 'standup' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'search', 'standup'], { account: undefined });
+  });
+
+  it('passes all filter flags when provided', async () => {
+    await handlers.get('gog_calendar_search')!({
+      query: 'standup',
+      from: 'today',
+      to: 'tomorrow',
+      today: true,
+      tomorrow: true,
+      week: true,
+      days: 7,
+      weekStart: 'sun',
+      calendar: 'primary',
+      max: 10,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'calendar', 'search', 'standup',
+        '--from=today', '--to=tomorrow',
+        '--today', '--tomorrow', '--week',
+        '--days=7', '--week-start=sun',
+        '--calendar=primary', '--max=10',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_calendar_search')!({
+      query: 'standup', today: false, tomorrow: false, week: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'search', 'standup'], { account: undefined });
+  });
+});
+
+describe('gog_calendar_freebusy', () => {
+  it('calls runOrDiagnose with required from/to only', async () => {
+    await handlers.get('gog_calendar_freebusy')!({ from: 'A', to: 'B' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'freebusy', '--from=A', '--to=B'],
+      { account: undefined },
+    );
+  });
+
+  it('passes calendarIds and --all when provided', async () => {
+    await handlers.get('gog_calendar_freebusy')!({
+      from: 'A', to: 'B', calendarIds: 'primary,team@x.com', all: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'freebusy', 'primary,team@x.com', '--from=A', '--to=B', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_calendar_freebusy')!({ from: 'A', to: 'B', all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'freebusy', '--from=A', '--to=B'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_calendar_colors', () => {
+  it('calls runOrDiagnose with the colors subcommand', async () => {
+    await handlers.get('gog_calendar_colors')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'colors'], { account: undefined });
+  });
+});
+
+describe('gog_calendar_acl', () => {
+  it('calls runOrDiagnose with calendarId only', async () => {
+    await handlers.get('gog_calendar_acl')!({ calendarId: 'primary' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'acl', 'primary'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    await handlers.get('gog_calendar_acl')!({ calendarId: 'primary', max: 25, page: 'tok', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'acl', 'primary', '--max=25', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all when false', async () => {
+    await handlers.get('gog_calendar_acl')!({ calendarId: 'primary', all: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['calendar', 'acl', 'primary'], { account: undefined });
+  });
+});
+
+describe('gog_calendar_move', () => {
+  it('calls runOrDiagnose with the three positionals', async () => {
+    await handlers.get('gog_calendar_move')!({
+      calendarId: 'primary', eventId: 'ev1', destinationCalendarId: 'team@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'move', 'primary', 'ev1', 'team@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --send-updates when provided', async () => {
+    await handlers.get('gog_calendar_move')!({
+      calendarId: 'primary', eventId: 'ev1', destinationCalendarId: 'team@x.com',
+      sendUpdates: 'all',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'move', 'primary', 'ev1', 'team@x.com', '--send-updates=all'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_calendar_out_of_office', () => {
+  it('calls runOrDiagnose with required from/to only', async () => {
+    await handlers.get('gog_calendar_out_of_office')!({ from: '2026-06-01', to: '2026-06-05' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'out-of-office', '--from=2026-06-01', '--to=2026-06-05'],
+      { account: undefined },
+    );
+  });
+
+  it('passes calendarId and all optional flags when provided', async () => {
+    await handlers.get('gog_calendar_out_of_office')!({
+      from: '2026-06-01', to: '2026-06-05',
+      calendarId: 'primary',
+      summary: 'Vacation',
+      autoDecline: 'new',
+      declineMessage: 'Away',
+      allDay: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'calendar', 'out-of-office', 'primary',
+        '--from=2026-06-01', '--to=2026-06-05',
+        '--summary=Vacation', '--auto-decline=new',
+        '--decline-message=Away', '--all-day',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits --all-day when false', async () => {
+    await handlers.get('gog_calendar_out_of_office')!({ from: '2026-06-01', to: '2026-06-05', allDay: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['calendar', 'out-of-office', '--from=2026-06-01', '--to=2026-06-05'],
+      { account: undefined },
+    );
+  });
+});
+
 describe('gog_meet_participants', () => {
   it('calls runOrDiagnose with meetingCode', async () => {
     await handlers.get('gog_meet_participants')!({ meetingCode: 'abc-defg-hij' });