gogcli-mcp-gmail 2.2.0 → 2.4.0

package/dist/index.js

@@ -31241,11 +31241,13 @@ function registerGmailTools(server2) {
     inputSchema: {
       query: external_exports.string().describe("Gmail search query"),
       max: external_exports.number().int().optional().describe("Max results to return (default: 10)"),
+      fromContact: external_exports.string().optional().describe("Resolve a Google Contact (name or email) to its addresses and AND a from:(addr OR addr) clause onto the query \u2014 saves looking the contact up first when you only know who, not which address."),
       account: accountParam
     }
-  }, async ({ query, max, account }) => {
+  }, async ({ query, max, fromContact, account }) => {
     const args = ["gmail", "search", query];
     if (max !== void 0) args.push(`--max=${max}`);
+    if (fromContact) args.push(`--from-contact=${fromContact}`);
     return runOrDiagnose(args, { account });
   });
   server2.registerTool("gog_gmail_get", {
@@ -31295,7 +31297,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.4.0" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31763,6 +31765,225 @@ function registerExtraGmailTools(server2) {
     if (allowSelf) args.push("--allow-self");
     return runOrDiagnose(args, { account });
   });
+  server2.registerTool("gog_gmail_messages_search", {
+    description: "Search individual messages (not threads) using Gmail query syntax. Returns one result per matching message.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: external_exports.string().describe('Gmail search query (e.g. "from:alice is:unread has:attachment")'),
+      max: external_exports.number().optional().describe("Max results"),
+      page: external_exports.string().optional().describe("Page token"),
+      all: external_exports.boolean().optional().describe("Fetch all pages"),
+      includeBody: external_exports.boolean().optional().describe("Include the decoded message body in each result"),
+      full: external_exports.boolean().optional().describe("Show full message bodies without truncation (implies includeBody)"),
+      bodyFormat: external_exports.enum(["text", "html"]).optional().describe("Body format preference when includeBody is set"),
+      account: accountParam
+    }
+  }, async ({ query, max, page, all, includeBody, full, bodyFormat, account }) => {
+    const args = ["gmail", "messages", "search", query];
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push("--all");
+    if (includeBody) args.push("--include-body");
+    if (full) args.push("--full");
+    if (bodyFormat) args.push(`--body-format=${bodyFormat}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_labels_style", {
+    description: "Change a user label's color or visibility (background/text color from Gmail's palette, label-list and message-list visibility).",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      labelIdOrName: external_exports.string().describe("Label ID or name to restyle"),
+      backgroundColor: external_exports.string().optional().describe("Background color from Gmail's label palette as #RRGGBB"),
+      textColor: external_exports.string().optional().describe("Text color from Gmail's label palette as #RRGGBB"),
+      labelListVisibility: external_exports.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional().describe("Label-list visibility"),
+      messageListVisibility: external_exports.enum(["show", "hide"]).optional().describe("Message-list visibility"),
+      account: accountParam
+    }
+  }, async ({ labelIdOrName, backgroundColor, textColor, labelListVisibility, messageListVisibility, account }) => {
+    const args = ["gmail", "labels", "style", labelIdOrName];
+    if (backgroundColor) args.push(`--background-color=${backgroundColor}`);
+    if (textColor) args.push(`--text-color=${textColor}`);
+    if (labelListVisibility) args.push(`--label-list-visibility=${labelListVisibility}`);
+    if (messageListVisibility) args.push(`--message-list-visibility=${messageListVisibility}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_vacation_get", {
+    description: "Get the current vacation responder (auto-reply) settings.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["gmail", "settings", "vacation", "get"], { account });
+  });
+  server2.registerTool("gog_gmail_vacation_update", {
+    description: "Update the vacation responder. Pass enable (with subject/body) to turn it on, or disable to turn it off; optional start/end RFC3339 times and contactsOnly/domainOnly scoping.",
+    inputSchema: {
+      enable: external_exports.boolean().optional().describe("Enable the vacation responder"),
+      disable: external_exports.boolean().optional().describe("Disable the vacation responder"),
+      subject: external_exports.string().optional().describe("Subject line for the auto-reply"),
+      body: external_exports.string().optional().describe("HTML body of the auto-reply message"),
+      start: external_exports.string().optional().describe("Start time in RFC3339 format (e.g. 2024-12-20T00:00:00Z)"),
+      end: external_exports.string().optional().describe("End time in RFC3339 format (e.g. 2024-12-31T23:59:59Z)"),
+      contactsOnly: external_exports.boolean().optional().describe("Only respond to contacts"),
+      domainOnly: external_exports.boolean().optional().describe("Only respond to senders in the same domain"),
+      account: accountParam
+    }
+  }, async ({ enable, disable, subject, body, start, end, contactsOnly, domainOnly, account }) => {
+    const args = ["gmail", "settings", "vacation", "update"];
+    if (enable) args.push("--enable");
+    if (disable) args.push("--disable");
+    if (subject) args.push(`--subject=${subject}`);
+    if (body) args.push(`--body=${body}`);
+    if (start) args.push(`--start=${start}`);
+    if (end) args.push(`--end=${end}`);
+    if (contactsOnly) args.push("--contacts-only");
+    if (domainOnly) args.push("--domain-only");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_filters_list", {
+    description: "List all Gmail filters for the account.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["gmail", "settings", "filters", "list"], { account });
+  });
+  server2.registerTool("gog_gmail_filters_get", {
+    description: "Get the criteria and actions of a single Gmail filter by ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      filterId: external_exports.string().describe("Filter ID"),
+      account: accountParam
+    }
+  }, async ({ filterId, account }) => {
+    return runOrDiagnose(["gmail", "settings", "filters", "get", filterId], { account });
+  });
+  server2.registerTool("gog_gmail_filters_create", {
+    description: "Create a Gmail filter. Specify match criteria (from/to/subject/query/hasAttachment) and one or more actions (label, archive, mark-read, star, important, trash, forward, never-spam).",
+    inputSchema: {
+      from: external_exports.string().optional().describe("Match messages from this sender"),
+      to: external_exports.string().optional().describe("Match messages to this recipient"),
+      subject: external_exports.string().optional().describe("Match messages with this subject"),
+      query: external_exports.string().optional().describe("Advanced Gmail search query for matching"),
+      hasAttachment: external_exports.boolean().optional().describe("Match messages with attachments"),
+      addLabel: external_exports.string().optional().describe("Label(s) to add to matching messages (comma-separated, name or ID)"),
+      removeLabel: external_exports.string().optional().describe("Label(s) to remove from matching messages (comma-separated, name or ID)"),
+      archive: external_exports.boolean().optional().describe("Archive matching messages (skip inbox)"),
+      markRead: external_exports.boolean().optional().describe("Mark matching messages as read"),
+      star: external_exports.boolean().optional().describe("Star matching messages"),
+      important: external_exports.boolean().optional().describe("Mark as important"),
+      trash: external_exports.boolean().optional().describe("Move matching messages to trash"),
+      neverSpam: external_exports.boolean().optional().describe("Never mark as spam"),
+      forward: external_exports.string().optional().describe("Forward to this email address (must be a verified forwarding address)"),
+      account: accountParam
+    }
+  }, async ({ from, to, subject, query, hasAttachment, addLabel, removeLabel, archive, markRead, star, important, trash, neverSpam, forward, account }) => {
+    const args = ["gmail", "settings", "filters", "create"];
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (subject) args.push(`--subject=${subject}`);
+    if (query) args.push(`--query=${query}`);
+    if (hasAttachment) args.push("--has-attachment");
+    if (addLabel) args.push(`--add-label=${addLabel}`);
+    if (removeLabel) args.push(`--remove-label=${removeLabel}`);
+    if (archive) args.push("--archive");
+    if (markRead) args.push("--mark-read");
+    if (star) args.push("--star");
+    if (important) args.push("--important");
+    if (trash) args.push("--trash");
+    if (neverSpam) args.push("--never-spam");
+    if (forward) args.push(`--forward=${forward}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_filters_delete", {
+    description: "Delete a Gmail filter by ID.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      filterId: external_exports.string().describe("Filter ID to delete"),
+      account: accountParam
+    }
+  }, async ({ filterId, account }) => {
+    return runOrDiagnose(["gmail", "settings", "filters", "delete", filterId], { account });
+  });
+  server2.registerTool("gog_gmail_sendas_list", {
+    description: "List all send-as aliases configured for the account.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam
+    }
+  }, async ({ account }) => {
+    return runOrDiagnose(["gmail", "settings", "sendas", "list"], { account });
+  });
+  server2.registerTool("gog_gmail_sendas_get", {
+    description: "Get details of a single send-as alias by its email address.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      email: external_exports.string().describe("Send-as alias email address"),
+      account: accountParam
+    }
+  }, async ({ email: email3, account }) => {
+    return runOrDiagnose(["gmail", "settings", "sendas", "get", email3], { account });
+  });
+  server2.registerTool("gog_gmail_sendas_create", {
+    description: "Create a send-as alias. Newly added aliases generally require email verification before they can be used (see gog_gmail_sendas_verify).",
+    inputSchema: {
+      email: external_exports.string().describe("Email address of the new send-as alias"),
+      displayName: external_exports.string().optional().describe("Name that appears in the From field"),
+      replyTo: external_exports.string().optional().describe("Reply-to address"),
+      signature: external_exports.string().optional().describe("HTML signature for emails sent from this alias"),
+      treatAsAlias: external_exports.boolean().optional().describe("Treat as alias (replies sent from Gmail web)"),
+      account: accountParam
+    }
+  }, async ({ email: email3, displayName, replyTo, signature, treatAsAlias, account }) => {
+    const args = ["gmail", "settings", "sendas", "create", email3];
+    if (displayName) args.push(`--display-name=${displayName}`);
+    if (replyTo) args.push(`--reply-to=${replyTo}`);
+    if (signature) args.push(`--signature=${signature}`);
+    if (treatAsAlias) args.push("--treat-as-alias");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_sendas_update", {
+    description: "Update a send-as alias (display name, reply-to, signature, alias handling, or make it the default).",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      email: external_exports.string().describe("Send-as alias email address to update"),
+      displayName: external_exports.string().optional().describe("Name that appears in the From field"),
+      replyTo: external_exports.string().optional().describe("Reply-to address"),
+      signature: external_exports.string().optional().describe("HTML signature"),
+      treatAsAlias: external_exports.boolean().optional().describe("Treat as alias"),
+      makeDefault: external_exports.boolean().optional().describe("Make this the default send-as address"),
+      account: accountParam
+    }
+  }, async ({ email: email3, displayName, replyTo, signature, treatAsAlias, makeDefault, account }) => {
+    const args = ["gmail", "settings", "sendas", "update", email3];
+    if (displayName) args.push(`--display-name=${displayName}`);
+    if (replyTo) args.push(`--reply-to=${replyTo}`);
+    if (signature) args.push(`--signature=${signature}`);
+    if (treatAsAlias) args.push("--treat-as-alias");
+    if (makeDefault) args.push("--make-default");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_gmail_sendas_delete", {
+    description: "Delete a send-as alias by its email address.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      email: external_exports.string().describe("Send-as alias email address to delete"),
+      account: accountParam
+    }
+  }, async ({ email: email3, account }) => {
+    return runOrDiagnose(["gmail", "settings", "sendas", "delete", email3], { account });
+  });
+  server2.registerTool("gog_gmail_sendas_verify", {
+    description: "Resend the verification email for a send-as alias that is pending verification.",
+    inputSchema: {
+      email: external_exports.string().describe("Send-as alias email address to verify"),
+      account: accountParam
+    }
+  }, async ({ email: email3, account }) => {
+    return runOrDiagnose(["gmail", "settings", "sendas", "verify", email3], { account });
+  });
 }
 
 // src/index.ts

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-gmail",
   "display_name": "gogcli (Gmail)",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Extended Gmail for Claude via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": {
     "name": "Chris Hall",
@@ -204,6 +204,62 @@
     {
       "name": "gog_gmail_autoreply",
       "description": "Reply once to all messages matching a Gmail search query"
+    },
+    {
+      "name": "gog_gmail_messages_search",
+      "description": "Search individual messages (not threads) using Gmail query syntax"
+    },
+    {
+      "name": "gog_gmail_labels_style",
+      "description": "Change a user label's color or visibility"
+    },
+    {
+      "name": "gog_gmail_vacation_get",
+      "description": "Get the current vacation responder settings"
+    },
+    {
+      "name": "gog_gmail_vacation_update",
+      "description": "Enable, disable, or update the vacation responder"
+    },
+    {
+      "name": "gog_gmail_filters_list",
+      "description": "List all Gmail filters"
+    },
+    {
+      "name": "gog_gmail_filters_get",
+      "description": "Get a single Gmail filter's criteria and actions"
+    },
+    {
+      "name": "gog_gmail_filters_create",
+      "description": "Create a Gmail filter with match criteria and actions"
+    },
+    {
+      "name": "gog_gmail_filters_delete",
+      "description": "Delete a Gmail filter by ID"
+    },
+    {
+      "name": "gog_gmail_sendas_list",
+      "description": "List all send-as aliases for the account"
+    },
+    {
+      "name": "gog_gmail_sendas_get",
+      "description": "Get details of a single send-as alias"
+    },
+    {
+      "name": "gog_gmail_sendas_create",
+      "description": "Create a send-as alias"
+    },
+    {
+      "name": "gog_gmail_sendas_update",
+      "description": "Update a send-as alias or make it the default"
+    },
+    {
+      "name": "gog_gmail_sendas_delete",
+      "description": "Delete a send-as alias"
+    },
+    {
+      "name": "gog_gmail_sendas_verify",
+      "description": "Resend the verification email for a send-as alias"
     }
   ],
   "compatibility": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-gmail",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-gmail",
   "description": "Extended Gmail MCP server via gogcli — auth + full Gmail support (threads, labels, drafts, attachments, forward, autoreply, bulk operations)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/src/tools/gmail-extra.ts

@@ -543,4 +543,237 @@ export function registerExtraGmailTools(server: McpServer): void {
     if (allowSelf) args.push('--allow-self');
     return runOrDiagnose(args, { account });
   });
+
+  server.registerTool('gog_gmail_messages_search', {
+    description: 'Search individual messages (not threads) using Gmail query syntax. Returns one result per matching message.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      query: z.string().describe('Gmail search query (e.g. "from:alice is:unread has:attachment")'),
+      max: z.number().optional().describe('Max results'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      includeBody: z.boolean().optional().describe('Include the decoded message body in each result'),
+      full: z.boolean().optional().describe('Show full message bodies without truncation (implies includeBody)'),
+      bodyFormat: z.enum(['text', 'html']).optional().describe('Body format preference when includeBody is set'),
+      account: accountParam,
+    },
+  }, async ({ query, max, page, all, includeBody, full, bodyFormat, account }) => {
+    const args = ['gmail', 'messages', 'search', query];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    if (includeBody) args.push('--include-body');
+    if (full) args.push('--full');
+    if (bodyFormat) args.push(`--body-format=${bodyFormat}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_labels_style', {
+    description: "Change a user label's color or visibility (background/text color from Gmail's palette, label-list and message-list visibility).",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      labelIdOrName: z.string().describe('Label ID or name to restyle'),
+      backgroundColor: z.string().optional().describe("Background color from Gmail's label palette as #RRGGBB"),
+      textColor: z.string().optional().describe("Text color from Gmail's label palette as #RRGGBB"),
+      labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe('Label-list visibility'),
+      messageListVisibility: z.enum(['show', 'hide']).optional().describe('Message-list visibility'),
+      account: accountParam,
+    },
+  }, async ({ labelIdOrName, backgroundColor, textColor, labelListVisibility, messageListVisibility, account }) => {
+    const args = ['gmail', 'labels', 'style', labelIdOrName];
+    if (backgroundColor) args.push(`--background-color=${backgroundColor}`);
+    if (textColor) args.push(`--text-color=${textColor}`);
+    if (labelListVisibility) args.push(`--label-list-visibility=${labelListVisibility}`);
+    if (messageListVisibility) args.push(`--message-list-visibility=${messageListVisibility}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_vacation_get', {
+    description: 'Get the current vacation responder (auto-reply) settings.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam,
+    },
+  }, async ({ account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'vacation', 'get'], { account });
+  });
+
+  server.registerTool('gog_gmail_vacation_update', {
+    description: 'Update the vacation responder. Pass enable (with subject/body) to turn it on, or disable to turn it off; optional start/end RFC3339 times and contactsOnly/domainOnly scoping.',
+    inputSchema: {
+      enable: z.boolean().optional().describe('Enable the vacation responder'),
+      disable: z.boolean().optional().describe('Disable the vacation responder'),
+      subject: z.string().optional().describe('Subject line for the auto-reply'),
+      body: z.string().optional().describe('HTML body of the auto-reply message'),
+      start: z.string().optional().describe('Start time in RFC3339 format (e.g. 2024-12-20T00:00:00Z)'),
+      end: z.string().optional().describe('End time in RFC3339 format (e.g. 2024-12-31T23:59:59Z)'),
+      contactsOnly: z.boolean().optional().describe('Only respond to contacts'),
+      domainOnly: z.boolean().optional().describe('Only respond to senders in the same domain'),
+      account: accountParam,
+    },
+  }, async ({ enable, disable, subject, body, start, end, contactsOnly, domainOnly, account }) => {
+    const args = ['gmail', 'settings', 'vacation', 'update'];
+    if (enable) args.push('--enable');
+    if (disable) args.push('--disable');
+    if (subject) args.push(`--subject=${subject}`);
+    if (body) args.push(`--body=${body}`);
+    if (start) args.push(`--start=${start}`);
+    if (end) args.push(`--end=${end}`);
+    if (contactsOnly) args.push('--contacts-only');
+    if (domainOnly) args.push('--domain-only');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_filters_list', {
+    description: 'List all Gmail filters for the account.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam,
+    },
+  }, async ({ account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'filters', 'list'], { account });
+  });
+
+  server.registerTool('gog_gmail_filters_get', {
+    description: 'Get the criteria and actions of a single Gmail filter by ID.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      filterId: z.string().describe('Filter ID'),
+      account: accountParam,
+    },
+  }, async ({ filterId, account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'filters', 'get', filterId], { account });
+  });
+
+  server.registerTool('gog_gmail_filters_create', {
+    description: 'Create a Gmail filter. Specify match criteria (from/to/subject/query/hasAttachment) and one or more actions (label, archive, mark-read, star, important, trash, forward, never-spam).',
+    inputSchema: {
+      from: z.string().optional().describe('Match messages from this sender'),
+      to: z.string().optional().describe('Match messages to this recipient'),
+      subject: z.string().optional().describe('Match messages with this subject'),
+      query: z.string().optional().describe('Advanced Gmail search query for matching'),
+      hasAttachment: z.boolean().optional().describe('Match messages with attachments'),
+      addLabel: z.string().optional().describe('Label(s) to add to matching messages (comma-separated, name or ID)'),
+      removeLabel: z.string().optional().describe('Label(s) to remove from matching messages (comma-separated, name or ID)'),
+      archive: z.boolean().optional().describe('Archive matching messages (skip inbox)'),
+      markRead: z.boolean().optional().describe('Mark matching messages as read'),
+      star: z.boolean().optional().describe('Star matching messages'),
+      important: z.boolean().optional().describe('Mark as important'),
+      trash: z.boolean().optional().describe('Move matching messages to trash'),
+      neverSpam: z.boolean().optional().describe('Never mark as spam'),
+      forward: z.string().optional().describe('Forward to this email address (must be a verified forwarding address)'),
+      account: accountParam,
+    },
+  }, async ({ from, to, subject, query, hasAttachment, addLabel, removeLabel, archive, markRead, star, important, trash, neverSpam, forward, account }) => {
+    const args = ['gmail', 'settings', 'filters', 'create'];
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (subject) args.push(`--subject=${subject}`);
+    if (query) args.push(`--query=${query}`);
+    if (hasAttachment) args.push('--has-attachment');
+    if (addLabel) args.push(`--add-label=${addLabel}`);
+    if (removeLabel) args.push(`--remove-label=${removeLabel}`);
+    if (archive) args.push('--archive');
+    if (markRead) args.push('--mark-read');
+    if (star) args.push('--star');
+    if (important) args.push('--important');
+    if (trash) args.push('--trash');
+    if (neverSpam) args.push('--never-spam');
+    if (forward) args.push(`--forward=${forward}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_filters_delete', {
+    description: 'Delete a Gmail filter by ID.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      filterId: z.string().describe('Filter ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ filterId, account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'filters', 'delete', filterId], { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_list', {
+    description: 'List all send-as aliases configured for the account.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      account: accountParam,
+    },
+  }, async ({ account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'sendas', 'list'], { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_get', {
+    description: 'Get details of a single send-as alias by its email address.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      email: z.string().describe('Send-as alias email address'),
+      account: accountParam,
+    },
+  }, async ({ email, account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'sendas', 'get', email], { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_create', {
+    description: 'Create a send-as alias. Newly added aliases generally require email verification before they can be used (see gog_gmail_sendas_verify).',
+    inputSchema: {
+      email: z.string().describe('Email address of the new send-as alias'),
+      displayName: z.string().optional().describe('Name that appears in the From field'),
+      replyTo: z.string().optional().describe('Reply-to address'),
+      signature: z.string().optional().describe('HTML signature for emails sent from this alias'),
+      treatAsAlias: z.boolean().optional().describe('Treat as alias (replies sent from Gmail web)'),
+      account: accountParam,
+    },
+  }, async ({ email, displayName, replyTo, signature, treatAsAlias, account }) => {
+    const args = ['gmail', 'settings', 'sendas', 'create', email];
+    if (displayName) args.push(`--display-name=${displayName}`);
+    if (replyTo) args.push(`--reply-to=${replyTo}`);
+    if (signature) args.push(`--signature=${signature}`);
+    if (treatAsAlias) args.push('--treat-as-alias');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_update', {
+    description: 'Update a send-as alias (display name, reply-to, signature, alias handling, or make it the default).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      email: z.string().describe('Send-as alias email address to update'),
+      displayName: z.string().optional().describe('Name that appears in the From field'),
+      replyTo: z.string().optional().describe('Reply-to address'),
+      signature: z.string().optional().describe('HTML signature'),
+      treatAsAlias: z.boolean().optional().describe('Treat as alias'),
+      makeDefault: z.boolean().optional().describe('Make this the default send-as address'),
+      account: accountParam,
+    },
+  }, async ({ email, displayName, replyTo, signature, treatAsAlias, makeDefault, account }) => {
+    const args = ['gmail', 'settings', 'sendas', 'update', email];
+    if (displayName) args.push(`--display-name=${displayName}`);
+    if (replyTo) args.push(`--reply-to=${replyTo}`);
+    if (signature) args.push(`--signature=${signature}`);
+    if (treatAsAlias) args.push('--treat-as-alias');
+    if (makeDefault) args.push('--make-default');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_delete', {
+    description: 'Delete a send-as alias by its email address.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      email: z.string().describe('Send-as alias email address to delete'),
+      account: accountParam,
+    },
+  }, async ({ email, account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'sendas', 'delete', email], { account });
+  });
+
+  server.registerTool('gog_gmail_sendas_verify', {
+    description: 'Resend the verification email for a send-as alias that is pending verification.',
+    inputSchema: {
+      email: z.string().describe('Send-as alias email address to verify'),
+      account: accountParam,
+    },
+  }, async ({ email, account }) => {
+    return runOrDiagnose(['gmail', 'settings', 'sendas', 'verify', email], { account });
+  });
 }

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

@@ -748,3 +748,291 @@ describe('gog_gmail_autoreply', () => {
     );
   });
 });
+
+describe('gog_gmail_messages_search', () => {
+  it('calls runOrDiagnose with just the query', async () => {
+    await handlers.get('gog_gmail_messages_search')!({ query: 'from:alice' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'from:alice'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_messages_search')!({
+      query: 'is:unread',
+      max: 10,
+      page: 'tok',
+      all: true,
+      includeBody: true,
+      full: true,
+      bodyFormat: 'html',
+      account: 'me@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'is:unread', '--max=10', '--page=tok', '--all', '--include-body', '--full', '--body-format=html'],
+      { account: 'me@x.com' },
+    );
+  });
+
+  it('omits flags when false/absent', async () => {
+    await handlers.get('gog_gmail_messages_search')!({ query: 'x', all: false, includeBody: false, full: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'messages', 'search', 'x'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_labels_style', () => {
+  it('calls runOrDiagnose with just the label', async () => {
+    await handlers.get('gog_gmail_labels_style')!({ labelIdOrName: 'Work' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'style', 'Work'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all style flags when provided', async () => {
+    await handlers.get('gog_gmail_labels_style')!({
+      labelIdOrName: 'Work',
+      backgroundColor: '#000000',
+      textColor: '#ffffff',
+      labelListVisibility: 'labelHide',
+      messageListVisibility: 'hide',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'labels', 'style', 'Work', '--background-color=#000000', '--text-color=#ffffff', '--label-list-visibility=labelHide', '--message-list-visibility=hide'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_vacation_get', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_vacation_get')!({ account: 'me@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'get'],
+      { account: 'me@x.com' },
+    );
+  });
+});
+
+describe('gog_gmail_vacation_update', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update'],
+      { account: undefined },
+    );
+  });
+
+  it('enables with subject/body/start/end and scoping', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({
+      enable: true,
+      subject: 'Away',
+      body: '<p>OOO</p>',
+      start: '2024-12-20T00:00:00Z',
+      end: '2024-12-31T23:59:59Z',
+      contactsOnly: true,
+      domainOnly: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update', '--enable', '--subject=Away', '--body=<p>OOO</p>', '--start=2024-12-20T00:00:00Z', '--end=2024-12-31T23:59:59Z', '--contacts-only', '--domain-only'],
+      { account: undefined },
+    );
+  });
+
+  it('disables the responder', async () => {
+    await handlers.get('gog_gmail_vacation_update')!({ disable: true, enable: false, contactsOnly: false, domainOnly: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'vacation', 'update', '--disable'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_list', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_filters_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'list'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_get', () => {
+  it('calls runOrDiagnose with the filter ID', async () => {
+    await handlers.get('gog_gmail_filters_get')!({ filterId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'get', 'f1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_create', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_gmail_filters_create')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all criteria and actions when provided', async () => {
+    await handlers.get('gog_gmail_filters_create')!({
+      from: 'alice@x.com',
+      to: 'me@x.com',
+      subject: 'Report',
+      query: 'has:attachment',
+      hasAttachment: true,
+      addLabel: 'Reports',
+      removeLabel: 'INBOX',
+      archive: true,
+      markRead: true,
+      star: true,
+      important: true,
+      trash: true,
+      neverSpam: true,
+      forward: 'fwd@x.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create', '--from=alice@x.com', '--to=me@x.com', '--subject=Report', '--query=has:attachment', '--has-attachment', '--add-label=Reports', '--remove-label=INBOX', '--archive', '--mark-read', '--star', '--important', '--trash', '--never-spam', '--forward=fwd@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_filters_create')!({
+      from: 'a@x.com',
+      hasAttachment: false,
+      archive: false,
+      markRead: false,
+      star: false,
+      important: false,
+      trash: false,
+      neverSpam: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'create', '--from=a@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_filters_delete', () => {
+  it('calls runOrDiagnose with the filter ID', async () => {
+    await handlers.get('gog_gmail_filters_delete')!({ filterId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'filters', 'delete', 'f1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_list', () => {
+  it('calls runOrDiagnose', async () => {
+    await handlers.get('gog_gmail_sendas_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'list'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_get', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_get')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'get', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_create', () => {
+  it('calls runOrDiagnose with just the email', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({
+      email: 'alias@x.com',
+      displayName: 'Alias',
+      replyTo: 'reply@x.com',
+      signature: '<p>sig</p>',
+      treatAsAlias: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com', '--display-name=Alias', '--reply-to=reply@x.com', '--signature=<p>sig</p>', '--treat-as-alias'],
+      { account: undefined },
+    );
+  });
+
+  it('omits treatAsAlias when false', async () => {
+    await handlers.get('gog_gmail_sendas_create')!({ email: 'alias@x.com', treatAsAlias: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'create', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_update', () => {
+  it('calls runOrDiagnose with just the email', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags when provided', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({
+      email: 'alias@x.com',
+      displayName: 'Alias',
+      replyTo: 'reply@x.com',
+      signature: '<p>sig</p>',
+      treatAsAlias: true,
+      makeDefault: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com', '--display-name=Alias', '--reply-to=reply@x.com', '--signature=<p>sig</p>', '--treat-as-alias', '--make-default'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_gmail_sendas_update')!({ email: 'alias@x.com', treatAsAlias: false, makeDefault: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'update', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_delete', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_delete')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'delete', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_gmail_sendas_verify', () => {
+  it('calls runOrDiagnose with the email', async () => {
+    await handlers.get('gog_gmail_sendas_verify')!({ email: 'alias@x.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['gmail', 'settings', 'sendas', 'verify', 'alias@x.com'],
+      { account: undefined },
+    );
+  });
+});