gogcli-mcp 1.0.0 → 1.0.2

package/dist/index.js

@@ -30115,6 +30115,7 @@ var StdioServerTransport = class {
 
 // src/runner.ts
 import { spawn } from "node:child_process";
+var TIMEOUT_MS = 3e4;
 async function run(args, options = {}) {
   const { account, spawner = spawn } = options;
   const effectiveAccount = account ?? process.env.GOG_ACCOUNT;
@@ -30124,10 +30125,15 @@ async function run(args, options = {}) {
   }
   fullArgs.push(...args);
   return new Promise((resolve, reject) => {
-    const child = spawner("gog", fullArgs, { env: process.env });
+    const child = spawner(process.env.GOG_PATH ?? "gog", fullArgs, { env: process.env });
     let stdout = "";
     let stderr = "";
     let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      child.kill();
+      reject(new Error(`gog timed out after ${TIMEOUT_MS}ms`));
+    }, TIMEOUT_MS);
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
     });
@@ -30135,6 +30141,7 @@ async function run(args, options = {}) {
       stderr += chunk.toString();
     });
     child.on("close", (code) => {
+      clearTimeout(timer);
       if (settled) return;
       settled = true;
       if (code === 0) {
@@ -30144,6 +30151,7 @@ async function run(args, options = {}) {
       }
     });
     child.on("error", (err) => {
+      clearTimeout(timer);
       if (settled) return;
       settled = true;
       reject(err);
@@ -30151,7 +30159,7 @@ async function run(args, options = {}) {
   });
 }
 
-// src/tools/sheets.ts
+// src/tools/utils.ts
 var accountParam = external_exports3.string().optional().describe(
   "Google account email to use (overrides GOG_ACCOUNT env var)"
 );
@@ -30161,6 +30169,510 @@ function toText(output) {
 function toError(err) {
   return toText(err instanceof Error ? `Error: ${err.message}` : String(err));
 }
+async function runOrDiagnose(args, options) {
+  try {
+    return toText(await run(args, options));
+  } catch (err) {
+    const base = toError(err);
+    try {
+      const accounts = await run(["auth", "list"]);
+      return toText(`${base.content[0].text}
+
+Configured accounts:
+${accounts}`);
+    } catch {
+      return base;
+    }
+  }
+}
+
+// src/tools/auth.ts
+function registerAuthTools(server2) {
+  server2.registerTool("gog_auth_list", {
+    description: "List all Google accounts stored in gogcli. Use this to check which accounts are configured and available.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {}
+  }, async () => {
+    try {
+      return toText(await run(["auth", "list"]));
+    } catch (err) {
+      return toError(err);
+    }
+  });
+  server2.registerTool("gog_auth_status", {
+    description: "Show gogcli auth configuration: keyring backend, credential files, and auth setup.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {}
+  }, async () => {
+    try {
+      return toText(await run(["auth", "status"]));
+    } catch (err) {
+      return toError(err);
+    }
+  });
+  server2.registerTool("gog_auth_services", {
+    description: "List all Google services supported by gogcli and the OAuth scopes each requires.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {}
+  }, async () => {
+    try {
+      return toText(await run(["auth", "services"]));
+    } catch (err) {
+      return toError(err);
+    }
+  });
+  server2.registerTool("gog_auth_run", {
+    description: "Run any gog auth subcommand. Run `gog auth --help` to see all available subcommands and flags. Note: gog auth add requires interactive browser auth and cannot be completed over MCP \u2014 run it in your terminal instead: gog auth add <email> --services <service>",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog auth subcommand, e.g. "remove", "alias", "tokens"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags")
+    }
+  }, async ({ subcommand, args }) => {
+    try {
+      return toText(await run(["auth", subcommand, ...args]));
+    } catch (err) {
+      return toError(err);
+    }
+  });
+}
+
+// src/tools/calendar.ts
+function registerCalendarTools(server2) {
+  server2.registerTool("gog_calendar_events", {
+    description: "List calendar events. Filters can be combined (e.g. --from + --to for a range, or --today for just today).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      calendarId: external_exports3.string().optional().describe("Calendar ID (default: primary calendar)"),
+      from: external_exports3.string().optional().describe("Start time filter (RFC3339, date, or natural language)"),
+      to: external_exports3.string().optional().describe("End time filter (RFC3339, date, or natural language)"),
+      today: external_exports3.boolean().optional().describe("Only show today's events"),
+      query: external_exports3.string().optional().describe("Free text search within events"),
+      all: external_exports3.boolean().optional().describe("Fetch events from all calendars"),
+      account: accountParam
+    }
+  }, async ({ calendarId, from, to, today, query, all, account }) => {
+    const args = ["calendar", "events"];
+    if (calendarId) args.push(calendarId);
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (today) args.push("--today");
+    if (query) args.push(`--query=${query}`);
+    if (all) args.push("--all");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_get", {
+    description: "Get a specific calendar event by ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      calendarId: external_exports3.string().describe("Calendar ID"),
+      eventId: external_exports3.string().describe("Event ID"),
+      account: accountParam
+    }
+  }, async ({ calendarId, eventId, account }) => {
+    return runOrDiagnose(["calendar", "event", calendarId, eventId], { account });
+  });
+  server2.registerTool("gog_calendar_create", {
+    description: "Create a calendar event.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      calendarId: external_exports3.string().describe('Calendar ID (use "primary" for the default calendar)'),
+      summary: external_exports3.string().describe("Event title"),
+      from: external_exports3.string().describe("Start time (RFC3339 or date for all-day events)"),
+      to: external_exports3.string().describe("End time (RFC3339 or date for all-day events)"),
+      description: external_exports3.string().optional().describe("Event description"),
+      location: external_exports3.string().optional().describe("Event location"),
+      attendees: external_exports3.string().optional().describe("Attendee emails, comma-separated"),
+      allDay: external_exports3.boolean().optional().describe("All-day event (use date-only in from/to)"),
+      account: accountParam
+    }
+  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, account }) => {
+    const args = ["calendar", "create", calendarId, `--summary=${summary}`, `--from=${from}`, `--to=${to}`];
+    if (description) args.push(`--description=${description}`);
+    if (location) args.push(`--location=${location}`);
+    if (attendees) args.push(`--attendees=${attendees}`);
+    if (allDay) args.push("--all-day");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_update", {
+    description: "Update an existing calendar event.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      calendarId: external_exports3.string().describe("Calendar ID"),
+      eventId: external_exports3.string().describe("Event ID"),
+      summary: external_exports3.string().optional().describe("New event title"),
+      from: external_exports3.string().optional().describe("New start time (RFC3339)"),
+      to: external_exports3.string().optional().describe("New end time (RFC3339)"),
+      description: external_exports3.string().optional().describe("New description"),
+      location: external_exports3.string().optional().describe("New location"),
+      attendees: external_exports3.string().optional().describe("New attendee emails, comma-separated (replaces existing)"),
+      account: accountParam
+    }
+  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, account }) => {
+    const args = ["calendar", "update", calendarId, eventId];
+    if (summary !== void 0) args.push(`--summary=${summary}`);
+    if (from !== void 0) args.push(`--from=${from}`);
+    if (to !== void 0) args.push(`--to=${to}`);
+    if (description !== void 0) args.push(`--description=${description}`);
+    if (location !== void 0) args.push(`--location=${location}`);
+    if (attendees !== void 0) args.push(`--attendees=${attendees}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_delete", {
+    description: "Delete a calendar event.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      calendarId: external_exports3.string().describe("Calendar ID"),
+      eventId: external_exports3.string().describe("Event ID"),
+      account: accountParam
+    }
+  }, async ({ calendarId, eventId, account }) => {
+    return runOrDiagnose(["calendar", "delete", calendarId, eventId], { account });
+  });
+  server2.registerTool("gog_calendar_respond", {
+    description: "Respond to a calendar event invitation.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      calendarId: external_exports3.string().describe("Calendar ID"),
+      eventId: external_exports3.string().describe("Event ID"),
+      status: external_exports3.enum(["accepted", "declined", "tentative"]).describe("Response status"),
+      comment: external_exports3.string().optional().describe("Optional comment to include with response"),
+      account: accountParam
+    }
+  }, async ({ calendarId, eventId, status, comment, account }) => {
+    const args = ["calendar", "respond", calendarId, eventId, `--status=${status}`];
+    if (comment) args.push(`--comment=${comment}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_calendar_run", {
+    description: "Run any gog calendar subcommand not covered by the other tools. Run `gog calendar --help` for the full list of subcommands, or `gog calendar <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog calendar subcommand to run, e.g. "calendars", "freebusy"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["calendar", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/contacts.ts
+function registerContactsTools(server2) {
+  server2.registerTool("gog_contacts_search", {
+    description: "Search Google Contacts by name, email, or phone.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: external_exports3.string().describe("Search query (name, email, or phone)"),
+      account: accountParam
+    }
+  }, async ({ query, account }) => {
+    return runOrDiagnose(["contacts", "search", query], { account });
+  });
+  server2.registerTool("gog_contacts_list", {
+    description: "List all Google Contacts.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["contacts", "list"], { account });
+  });
+  server2.registerTool("gog_contacts_get", {
+    description: "Get a contact by resource name.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      resourceName: external_exports3.string().describe("Contact resource name (e.g. people/c12345)"),
+      account: accountParam
+    }
+  }, async ({ resourceName, account }) => {
+    return runOrDiagnose(["contacts", "get", resourceName], { account });
+  });
+  server2.registerTool("gog_contacts_create", {
+    description: "Create a new Google Contact.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      givenName: external_exports3.string().describe("Given (first) name"),
+      familyName: external_exports3.string().optional().describe("Family (last) name"),
+      email: external_exports3.string().optional().describe("Email address"),
+      phone: external_exports3.string().optional().describe("Phone number"),
+      org: external_exports3.string().optional().describe("Organization/company name"),
+      title: external_exports3.string().optional().describe("Job title"),
+      account: accountParam
+    }
+  }, async ({ givenName, familyName, email: email3, phone, org, title, account }) => {
+    const args = ["contacts", "create", `--given=${givenName}`];
+    if (familyName) args.push(`--family=${familyName}`);
+    if (email3) args.push(`--email=${email3}`);
+    if (phone) args.push(`--phone=${phone}`);
+    if (org) args.push(`--org=${org}`);
+    if (title) args.push(`--title=${title}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_contacts_run", {
+    description: "Run any gog contacts subcommand not covered by the other tools. Run `gog contacts --help` for the full list of subcommands, or `gog contacts <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog contacts subcommand to run, e.g. "update", "delete", "directory"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["contacts", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/docs.ts
+function registerDocsTools(server2) {
+  server2.registerTool("gog_docs_info", {
+    description: "Get Google Doc metadata: title, ID, and other properties.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: external_exports3.string().describe("Doc ID (from the URL)"),
+      account: accountParam
+    }
+  }, async ({ docId, account }) => {
+    return runOrDiagnose(["docs", "info", docId], { account });
+  });
+  server2.registerTool("gog_docs_cat", {
+    description: "Read a Google Doc as plain text.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: external_exports3.string().describe("Doc ID (from the URL)"),
+      account: accountParam
+    }
+  }, async ({ docId, account }) => {
+    return runOrDiagnose(["docs", "cat", docId], { account });
+  });
+  server2.registerTool("gog_docs_create", {
+    description: "Create a new Google Doc. Returns JSON with the new docId and URL.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      title: external_exports3.string().describe("Title for the new document"),
+      account: accountParam
+    }
+  }, async ({ title, account }) => {
+    return runOrDiagnose(["docs", "create", title], { account });
+  });
+  server2.registerTool("gog_docs_write", {
+    description: "Write text content to a Google Doc, replacing existing body content by default. Set append=true to add after existing content.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: external_exports3.string().describe("Doc ID (from the URL)"),
+      text: external_exports3.string().describe("Text content to write"),
+      append: external_exports3.boolean().optional().describe("Append to existing content instead of replacing (default: false)"),
+      account: accountParam
+    }
+  }, async ({ docId, text, append, account }) => {
+    const args = ["docs", "write", docId, `--text=${text}`];
+    if (append) args.push("--append");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_docs_find_replace", {
+    description: "Find and replace text in a Google Doc.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      docId: external_exports3.string().describe("Doc ID (from the URL)"),
+      find: external_exports3.string().describe("Text to find"),
+      replace: external_exports3.string().describe("Replacement text"),
+      account: accountParam
+    }
+  }, async ({ docId, find, replace, account }) => {
+    return runOrDiagnose(["docs", "find-replace", docId, find, replace], { account });
+  });
+  server2.registerTool("gog_docs_structure", {
+    description: "Show a Google Doc's structure with numbered paragraphs. Useful for understanding the document layout before making index-based edits.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      docId: external_exports3.string().describe("Doc ID (from the URL)"),
+      account: accountParam
+    }
+  }, async ({ docId, account }) => {
+    return runOrDiagnose(["docs", "structure", docId], { account });
+  });
+  server2.registerTool("gog_docs_run", {
+    description: "Run any gog docs subcommand not covered by the other tools. Run `gog docs --help` for the full list of subcommands, or `gog docs <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog docs subcommand to run, e.g. "copy", "clear", "insert", "sed", "export"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["docs", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/drive.ts
+function registerDriveTools(server2) {
+  server2.registerTool("gog_drive_ls", {
+    description: "List files in a Google Drive folder (default: root).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      folderId: external_exports3.string().optional().describe("Folder ID to list (default: root)"),
+      account: accountParam
+    }
+  }, async ({ folderId, account }) => {
+    const args = ["drive", "ls"];
+    if (folderId) args.push(folderId);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_search", {
+    description: "Search Google Drive files by full-text query.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: external_exports3.string().describe("Search query"),
+      account: accountParam
+    }
+  }, async ({ query, account }) => {
+    return runOrDiagnose(["drive", "search", query], { account });
+  });
+  server2.registerTool("gog_drive_get", {
+    description: "Get metadata for a Google Drive file.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: external_exports3.string().describe("File ID"),
+      account: accountParam
+    }
+  }, async ({ fileId, account }) => {
+    return runOrDiagnose(["drive", "get", fileId], { account });
+  });
+  server2.registerTool("gog_drive_mkdir", {
+    description: "Create a new folder in Google Drive.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      name: external_exports3.string().describe("Folder name"),
+      account: accountParam
+    }
+  }, async ({ name, account }) => {
+    return runOrDiagnose(["drive", "mkdir", name], { account });
+  });
+  server2.registerTool("gog_drive_rename", {
+    description: "Rename a file or folder in Google Drive.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: external_exports3.string().describe("File or folder ID"),
+      newName: external_exports3.string().describe("New name"),
+      account: accountParam
+    }
+  }, async ({ fileId, newName, account }) => {
+    return runOrDiagnose(["drive", "rename", fileId, newName], { account });
+  });
+  server2.registerTool("gog_drive_move", {
+    description: "Move a file to a different folder in Google Drive.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: external_exports3.string().describe("File ID to move"),
+      parentId: external_exports3.string().describe("Destination folder ID"),
+      account: accountParam
+    }
+  }, async ({ fileId, parentId, account }) => {
+    return runOrDiagnose(["drive", "move", fileId, `--parent=${parentId}`], { account });
+  });
+  server2.registerTool("gog_drive_delete", {
+    description: "Move a Google Drive file to trash.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: external_exports3.string().describe("File ID to trash"),
+      account: accountParam
+    }
+  }, async ({ fileId, account }) => {
+    return runOrDiagnose(["drive", "delete", fileId], { account });
+  });
+  server2.registerTool("gog_drive_share", {
+    description: "Share a Google Drive file or folder.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: external_exports3.string().describe("File or folder ID"),
+      to: external_exports3.enum(["user", "anyone", "domain"]).describe("Share target type"),
+      email: external_exports3.string().optional().describe("User email (required when to=user)"),
+      domain: external_exports3.string().optional().describe("Domain (required when to=domain)"),
+      role: external_exports3.enum(["reader", "writer"]).optional().describe("Permission role (default: reader)"),
+      account: accountParam
+    }
+  }, async ({ fileId, to, email: email3, domain: domain2, role, account }) => {
+    const args = ["drive", "share", fileId, `--to=${to}`];
+    if (email3) args.push(`--email=${email3}`);
+    if (domain2) args.push(`--domain=${domain2}`);
+    if (role) args.push(`--role=${role}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_run", {
+    description: "Run any gog drive subcommand not covered by the other tools. Run `gog drive --help` for the full list of subcommands, or `gog drive <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog drive subcommand to run, e.g. "copy", "upload", "download", "permissions"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["drive", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/gmail.ts
+function registerGmailTools(server2) {
+  server2.registerTool("gog_gmail_search", {
+    description: 'Search Gmail threads using Gmail query syntax (e.g. "from:alice subject:invoice is:unread").',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: external_exports3.string().describe("Gmail search query"),
+      max: external_exports3.number().int().optional().describe("Max results to return (default: 10)"),
+      account: accountParam
+    }
+  }, async ({ query, max, account }) => {
+    const args = ["gmail", "search", query];
+    if (max !== void 0) args.push(`--max=${max}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_get", {
+    description: "Get a Gmail message by ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      messageId: external_exports3.string().describe("Message ID"),
+      format: external_exports3.enum(["full", "metadata", "raw"]).optional().describe("Message format (default: full)"),
+      account: accountParam
+    }
+  }, async ({ messageId, format, account }) => {
+    const args = ["gmail", "get", messageId];
+    if (format) args.push(`--format=${format}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_send", {
+    description: "Send an email.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      to: external_exports3.string().describe("Recipient(s), comma-separated"),
+      subject: external_exports3.string().describe("Subject line"),
+      body: external_exports3.string().describe("Email body (plain text)"),
+      cc: external_exports3.string().optional().describe("CC recipients, comma-separated"),
+      bcc: external_exports3.string().optional().describe("BCC recipients, comma-separated"),
+      replyToMessageId: external_exports3.string().optional().describe("Message ID to reply to"),
+      threadId: external_exports3.string().optional().describe("Thread ID to reply within"),
+      account: accountParam
+    }
+  }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, account }) => {
+    const args = ["gmail", "send", `--to=${to}`, `--subject=${subject}`, `--body=${body}`];
+    if (cc) args.push(`--cc=${cc}`);
+    if (bcc) args.push(`--bcc=${bcc}`);
+    if (replyToMessageId) args.push(`--reply-to-message-id=${replyToMessageId}`);
+    if (threadId) args.push(`--thread-id=${threadId}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_run", {
+    description: "Run any gog gmail subcommand not covered by the other tools. Run `gog gmail --help` for the full list of subcommands, or `gog gmail <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog gmail subcommand to run, e.g. "archive", "mark-read", "labels"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["gmail", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/sheets.ts
 function registerSheetsTools(server2) {
   server2.registerTool("gog_sheets_get", {
     description: 'Read values from a Google Sheets range. Returns a JSON object with a "values" array of rows.',
@@ -30171,11 +30683,7 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, range, account }) => {
-    try {
-      return toText(await run(["sheets", "get", spreadsheetId, range], { account }));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(["sheets", "get", spreadsheetId, range], { account });
   });
   server2.registerTool("gog_sheets_update", {
     description: "Write values to a Google Sheets range, overwriting existing content.",
@@ -30187,14 +30695,10 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, range, values, account }) => {
-    try {
-      return toText(await run(
-        ["sheets", "update", spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
-        { account }
-      ));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(
+      ["sheets", "update", spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
+      { account }
+    );
   });
   server2.registerTool("gog_sheets_append", {
     description: "Append rows to a Google Sheet after the last row with data in the given range.",
@@ -30206,14 +30710,10 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, range, values, account }) => {
-    try {
-      return toText(await run(
-        ["sheets", "append", spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
-        { account }
-      ));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(
+      ["sheets", "append", spreadsheetId, range, `--values-json=${JSON.stringify(values)}`],
+      { account }
+    );
   });
   server2.registerTool("gog_sheets_clear", {
     description: "Clear all values in a Google Sheets range (formatting is preserved).",
@@ -30224,11 +30724,7 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, range, account }) => {
-    try {
-      return toText(await run(["sheets", "clear", spreadsheetId, range], { account }));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(["sheets", "clear", spreadsheetId, range], { account });
   });
   server2.registerTool("gog_sheets_metadata", {
     description: "Get spreadsheet metadata: title, sheet tabs, named ranges, and other properties.",
@@ -30238,25 +30734,17 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, account }) => {
-    try {
-      return toText(await run(["sheets", "metadata", spreadsheetId], { account }));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(["sheets", "metadata", spreadsheetId], { account });
   });
   server2.registerTool("gog_sheets_create", {
     description: "Create a new Google Spreadsheet. Returns JSON with the new spreadsheetId and URL.",
-    annotations: { destructiveHint: true },
+    annotations: { destructiveHint: false },
     inputSchema: {
       title: external_exports3.string().describe("Title for the new spreadsheet"),
       account: accountParam
     }
   }, async ({ title, account }) => {
-    try {
-      return toText(await run(["sheets", "create", title], { account }));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(["sheets", "create", title], { account });
   });
   server2.registerTool("gog_sheets_find_replace", {
     description: "Find and replace text across an entire Google Spreadsheet.",
@@ -30268,14 +30756,10 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ spreadsheetId, find, replace, account }) => {
-    try {
-      return toText(await run(["sheets", "find-replace", spreadsheetId, find, replace], { account }));
-    } catch (err) {
-      return toError(err);
-    }
+    return runOrDiagnose(["sheets", "find-replace", spreadsheetId, find, replace], { account });
   });
   server2.registerTool("gog_sheets_run", {
-    description: "Run any gog sheets subcommand not covered by the other tools. See `gog sheets --help` for the full list of subcommands and their flags.",
+    description: "Run any gog sheets subcommand not covered by the other tools. Run `gog sheets --help` for the full list of subcommands, or `gog sheets <subcommand> --help` for flags on a specific subcommand.",
     annotations: { destructiveHint: true },
     inputSchema: {
       subcommand: external_exports3.string().describe('The gog sheets subcommand to run, e.g. "freeze", "add-tab", "rename-tab"'),
@@ -30283,16 +30767,102 @@ function registerSheetsTools(server2) {
       account: accountParam
     }
   }, async ({ subcommand, args, account }) => {
-    try {
-      return toText(await run(["sheets", subcommand, ...args], { account }));
-    } catch (err) {
-      return toError(err);
+    return runOrDiagnose(["sheets", subcommand, ...args], { account });
+  });
+}
+
+// src/tools/tasks.ts
+function registerTasksTools(server2) {
+  server2.registerTool("gog_tasks_lists", {
+    description: "List all Google Task lists.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["tasks", "lists", "list"], { account });
+  });
+  server2.registerTool("gog_tasks_list", {
+    description: "List tasks in a Google Task list.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      tasklistId: external_exports3.string().describe("Task list ID (use gog_tasks_lists to find IDs)"),
+      account: accountParam
     }
+  }, async ({ tasklistId, account }) => {
+    return runOrDiagnose(["tasks", "list", tasklistId], { account });
+  });
+  server2.registerTool("gog_tasks_get", {
+    description: "Get a specific task by ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      tasklistId: external_exports3.string().describe("Task list ID"),
+      taskId: external_exports3.string().describe("Task ID"),
+      account: accountParam
+    }
+  }, async ({ tasklistId, taskId, account }) => {
+    return runOrDiagnose(["tasks", "get", tasklistId, taskId], { account });
+  });
+  server2.registerTool("gog_tasks_add", {
+    description: "Add a task to a Google Task list.",
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      tasklistId: external_exports3.string().describe("Task list ID"),
+      title: external_exports3.string().describe("Task title"),
+      notes: external_exports3.string().optional().describe("Task notes/description"),
+      due: external_exports3.string().optional().describe("Due date (YYYY-MM-DD or RFC3339)"),
+      account: accountParam
+    }
+  }, async ({ tasklistId, title, notes, due, account }) => {
+    const args = ["tasks", "add", tasklistId, `--title=${title}`];
+    if (notes) args.push(`--notes=${notes}`);
+    if (due) args.push(`--due=${due}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_tasks_done", {
+    description: "Mark a task as completed.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      tasklistId: external_exports3.string().describe("Task list ID"),
+      taskId: external_exports3.string().describe("Task ID"),
+      account: accountParam
+    }
+  }, async ({ tasklistId, taskId, account }) => {
+    return runOrDiagnose(["tasks", "done", tasklistId, taskId], { account });
+  });
+  server2.registerTool("gog_tasks_delete", {
+    description: "Delete a task.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      tasklistId: external_exports3.string().describe("Task list ID"),
+      taskId: external_exports3.string().describe("Task ID"),
+      account: accountParam
+    }
+  }, async ({ tasklistId, taskId, account }) => {
+    return runOrDiagnose(["tasks", "delete", tasklistId, taskId], { account });
+  });
+  server2.registerTool("gog_tasks_run", {
+    description: "Run any gog tasks subcommand not covered by the other tools. Run `gog tasks --help` for the full list of subcommands, or `gog tasks <subcommand> --help` for flags on a specific subcommand.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      subcommand: external_exports3.string().describe('The gog tasks subcommand to run, e.g. "update", "undo", "clear"'),
+      args: external_exports3.array(external_exports3.string()).describe("Additional positional args and flags"),
+      account: accountParam
+    }
+  }, async ({ subcommand, args, account }) => {
+    return runOrDiagnose(["tasks", subcommand, ...args], { account });
   });
 }
 
 // src/index.ts
-var server = new McpServer({ name: "gogcli", version: "1.0.0" });
+var server = new McpServer({ name: "gogcli", version: "1.0.2" });
+registerAuthTools(server);
+registerCalendarTools(server);
+registerContactsTools(server);
+registerDocsTools(server);
+registerDriveTools(server);
+registerGmailTools(server);
 registerSheetsTools(server);
+registerTasksTools(server);
 var transport = new StdioServerTransport();
 await server.connect(transport);