hypermail-mcp 0.7.7 → 0.7.9

package/dist/cli.js

@@ -15606,7 +15606,7 @@ async function startLocalCallbackServer() {
       return;
     }
     const callbackUrl = new URL(req.url, redirectUri);
-    if (callbackUrl.pathname !== "/oauth2callback") {
+    if (callbackUrl.pathname !== "/callback") {
       sendHtml(res, 404, "Not found", "This local callback server only handles Gmail OAuth redirects.");
       return;
     }
@@ -15621,7 +15621,7 @@ async function startLocalCallbackServer() {
   });
   await new Promise((resolve, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
+    server.listen(33333, "127.0.0.1", () => {
       server.off("error", reject);
       resolve();
     });
@@ -15631,7 +15631,7 @@ async function startLocalCallbackServer() {
     closeServer();
     throw new Error("Failed to start local Gmail OAuth callback server");
   }
-  redirectUri = `http://127.0.0.1:${address.port}/oauth2callback`;
+  redirectUri = "http://127.0.0.1:33333/callback";
   function closeServer() {
     if (closed) return;
     closed = true;
@@ -17038,7 +17038,7 @@ function registerAccountTools(server, ctx) {
 }
 
 // src/tools/browse.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/html-to-markdown.ts
 import TurndownService from "turndown";
@@ -17066,32 +17066,288 @@ function selectBody(msg, format) {
   }
 }
 
-// src/tools/browse.ts
-function registerBrowseTools(server, ctx) {
-  const { registry, tools } = ctx;
-  const emailListOutputSchema = z4.object({
+// src/tools/new-emails.ts
+import { z as z4 } from "zod";
+var DEFAULT_LIMIT = 10;
+var BODY_LIMIT = 2e4;
+var PAGE_SIZE = 100;
+var MISSING_RECEIVED_AT = "1970-01-01T00:00:00.000Z";
+function registerNewEmailTool(server, ctx) {
+  const { store, registry, tools } = ctx;
+  if (!shouldRegister("get_new_emails", tools)) return;
+  const newEmailOutputSchema = z4.object({
     account: z4.string(),
-    count: z4.number(),
-    items: z4.array(emailSummaryOutputSchema),
-    skip: z4.number(),
-    hasMore: z4.boolean()
+    id: z4.string(),
+    subject: z4.string(),
+    from: emailAddrOutputSchema.optional(),
+    to: z4.array(emailAddrOutputSchema).optional(),
+    cc: z4.array(emailAddrOutputSchema).optional(),
+    bcc: z4.array(emailAddrOutputSchema).optional(),
+    receivedAt: z4.string().optional(),
+    preview: z4.string().optional(),
+    isRead: z4.boolean().optional(),
+    hasAttachments: z4.boolean().optional(),
+    folder: z4.string().optional(),
+    attachments: z4.array(attachmentMetaOutputSchema).optional(),
+    body: z4.string(),
+    bodyFormat: z4.literal("markdown"),
+    bodyTruncated: z4.boolean(),
+    bodyOriginalLength: z4.number()
   });
-  const searchEmailsOutputSchema = z4.object({
-    account: z4.string(),
+  const outputSchema = z4.object({
     count: z4.number(),
-    items: z4.array(emailSummaryOutputSchema)
+    emails: z4.array(newEmailOutputSchema),
+    errors: z4.array(z4.object({ account: z4.string(), message: z4.string() }))
+  });
+  server.registerTool(
+    "get_new_emails",
+    {
+      description: "Fetch a bounded batch of inbox emails not previously returned by this tool. Agents should call this on their own schedule. Bodies are returned as markdown and may be truncated.",
+      inputSchema: z4.object({
+        account: z4.string().email().optional().describe(
+          "Email account to poll. If omitted, polls all accounts with one global limit."
+        ),
+        limit: z4.number().int().min(0).default(DEFAULT_LIMIT).optional().describe(
+          "Maximum emails to return. Defaults to 10. Use 0 to initialize/check without fetching bodies."
+        )
+      }),
+      outputSchema
+    },
+    async (args) => {
+      const limit = args.limit ?? DEFAULT_LIMIT;
+      if (args.account) {
+        try {
+          const { provider, account } = registry.resolveByEmail(args.account);
+          const result = await collectCandidatesForAccount(store, provider, account);
+          const selected2 = oldestCandidatesFirst(result.candidates).slice(0, limit);
+          const emails2 = limit === 0 ? [] : await hydrateAndAdvance(store, provider, result.account, selected2);
+          const data2 = { count: emails2.length, emails: emails2, errors: [] };
+          return ok(data2, data2);
+        } catch (err) {
+          return fail(errMsg(err));
+        }
+      }
+      const accounts = store.listAccounts();
+      if (accounts.length === 0) {
+        return fail("no accounts registered. Call add_account first.");
+      }
+      const errors = [];
+      const collected = [];
+      const providersByEmail = /* @__PURE__ */ new Map();
+      const accountsByEmail = /* @__PURE__ */ new Map();
+      for (const stored of accounts) {
+        try {
+          const { provider, account } = registry.resolveByEmail(stored.email);
+          const result = await collectCandidatesForAccount(store, provider, account);
+          providersByEmail.set(result.account.email, provider);
+          accountsByEmail.set(result.account.email, result.account);
+          collected.push(...result.candidates);
+        } catch (err) {
+          errors.push({ account: stored.email, message: errMsg(err) });
+        }
+      }
+      const selected = oldestCandidatesFirst(collected).slice(0, limit);
+      const emails = [];
+      if (limit > 0) {
+        const byAccount = /* @__PURE__ */ new Map();
+        for (const candidate of selected) {
+          const items = byAccount.get(candidate.account.email) ?? [];
+          items.push(candidate);
+          byAccount.set(candidate.account.email, items);
+        }
+        for (const [email, accountCandidates] of byAccount) {
+          const provider = providersByEmail.get(email);
+          const account = accountsByEmail.get(email);
+          if (!provider || !account) continue;
+          try {
+            emails.push(
+              ...await hydrateAndAdvance(
+                store,
+                provider,
+                account,
+                accountCandidates
+              )
+            );
+          } catch (err) {
+            errors.push({ account: email, message: errMsg(err) });
+          }
+        }
+      }
+      const orderedEmails = emails.sort(compareNewEmailOutputOldestFirst);
+      const data = { count: orderedEmails.length, emails: orderedEmails, errors };
+      return ok(data, data);
+    }
+  );
+}
+async function collectCandidatesForAccount(store, provider, account) {
+  const checkpoint = normalizeCheckpoint(account.newEmailCheckpoint);
+  if (!checkpoint) {
+    await initializeCheckpoint(store, provider, account);
+    return { account, candidates: [] };
+  }
+  const deliveredAtCheckpoint = new Set(checkpoint.deliveredIdsAtReceivedAt ?? []);
+  const candidates = [];
+  let skip = 0;
+  while (true) {
+    const { items, hasMore } = await provider.listEmails(account, {
+      folder: "inbox",
+      limit: PAGE_SIZE,
+      skip
+    });
+    if (items.length === 0) break;
+    let sawOlderThanCheckpoint = false;
+    for (const item of items) {
+      const timestamp = effectiveReceivedAt(item.receivedAt);
+      const comparison = compareTimestamp(timestamp, checkpoint.receivedAt);
+      if (comparison > 0) {
+        candidates.push({ account, summary: item, timestamp });
+      } else if (comparison === 0) {
+        if (!deliveredAtCheckpoint.has(item.id)) {
+          candidates.push({ account, summary: item, timestamp });
+        }
+      } else {
+        sawOlderThanCheckpoint = true;
+      }
+    }
+    if (sawOlderThanCheckpoint || !hasMore) break;
+    skip += items.length;
+  }
+  return { account, candidates };
+}
+async function initializeCheckpoint(store, provider, account) {
+  const { items } = await provider.listEmails(account, {
+    folder: "inbox",
+    limit: PAGE_SIZE
+  });
+  const first = items[0];
+  const receivedAt = first ? effectiveReceivedAt(first.receivedAt) : (/* @__PURE__ */ new Date()).toISOString();
+  const deliveredIdsAtReceivedAt = items.filter((item) => effectiveReceivedAt(item.receivedAt) === receivedAt).map((item) => item.id);
+  await store.upsertAccount({
+    ...account,
+    newEmailCheckpoint: { receivedAt, deliveredIdsAtReceivedAt }
+  });
+}
+async function hydrateAndAdvance(store, provider, account, selected) {
+  if (selected.length === 0) return [];
+  const emails = [];
+  for (const candidate of selected) {
+    const full = await provider.readEmail(account, candidate.summary.id);
+    emails.push(formatNewEmail(account.email, full, candidate.summary));
+  }
+  await advanceCheckpoint(store, account, selected);
+  return emails;
+}
+function formatNewEmail(account, msg, summary) {
+  const body = selectBody(msg, "markdown");
+  const bodyTruncated = body.length > BODY_LIMIT;
+  return {
+    account,
+    id: msg.id,
+    subject: msg.subject,
+    from: msg.from,
+    to: msg.to,
+    cc: msg.cc,
+    bcc: msg.bcc,
+    receivedAt: msg.receivedAt ?? summary.receivedAt,
+    preview: msg.preview,
+    isRead: msg.isRead,
+    hasAttachments: msg.hasAttachments,
+    folder: msg.folder,
+    attachments: msg.attachments,
+    body: bodyTruncated ? body.slice(0, BODY_LIMIT) : body,
+    bodyFormat: "markdown",
+    bodyTruncated,
+    bodyOriginalLength: body.length
+  };
+}
+async function advanceCheckpoint(store, account, selected) {
+  const ordered = oldestCandidatesFirst(selected);
+  const newest = ordered[ordered.length - 1];
+  if (!newest) return;
+  const previous = normalizeCheckpoint(account.newEmailCheckpoint);
+  const newestTimestamp = newest.timestamp;
+  const idsAtNewest = ordered.filter((candidate) => candidate.timestamp === newestTimestamp).map((candidate) => candidate.summary.id);
+  let deliveredIdsAtReceivedAt = idsAtNewest;
+  if (previous?.receivedAt === newestTimestamp) {
+    deliveredIdsAtReceivedAt = [
+      .../* @__PURE__ */ new Set([
+        ...previous.deliveredIdsAtReceivedAt ?? [],
+        ...idsAtNewest
+      ])
+    ];
+  }
+  await store.upsertAccount({
+    ...account,
+    newEmailCheckpoint: {
+      receivedAt: newestTimestamp,
+      deliveredIdsAtReceivedAt
+    }
+  });
+}
+function normalizeCheckpoint(checkpoint) {
+  const receivedAt = normalizeTimestamp(checkpoint?.receivedAt);
+  if (!receivedAt) return null;
+  return {
+    receivedAt,
+    deliveredIdsAtReceivedAt: checkpoint?.deliveredIdsAtReceivedAt ?? []
+  };
+}
+function effectiveReceivedAt(receivedAt) {
+  return normalizeTimestamp(receivedAt) ?? MISSING_RECEIVED_AT;
+}
+function normalizeTimestamp(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return null;
+  return new Date(ms).toISOString();
+}
+function oldestCandidatesFirst(items) {
+  return [...items].sort((a, b) => {
+    const byTimestamp = compareTimestamp(a.timestamp, b.timestamp);
+    if (byTimestamp !== 0) return byTimestamp;
+    return a.summary.id.localeCompare(b.summary.id);
+  });
+}
+function compareNewEmailOutputOldestFirst(a, b) {
+  const byTimestamp = compareTimestamp(
+    effectiveReceivedAt(a.receivedAt),
+    effectiveReceivedAt(b.receivedAt)
+  );
+  if (byTimestamp !== 0) return byTimestamp;
+  return a.id.localeCompare(b.id);
+}
+function compareTimestamp(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+// src/tools/browse.ts
+function registerBrowseTools(server, ctx) {
+  const { store, registry, tools } = ctx;
+  const emailListOutputSchema = z5.object({
+    account: z5.string(),
+    count: z5.number(),
+    items: z5.array(emailSummaryOutputSchema),
+    skip: z5.number(),
+    hasMore: z5.boolean()
+  });
+  const searchEmailsOutputSchema = z5.object({
+    account: z5.string(),
+    count: z5.number(),
+    items: z5.array(emailSummaryOutputSchema)
   });
   if (shouldRegister("list_emails", tools)) {
     server.registerTool(
       "list_emails",
       {
         description: "List recent emails in a folder of the given account. Pass the user's email address as `account`; the server routes to the correct backend automatically.",
-        inputSchema: z4.object({
-          account: z4.string().email(),
-          folder: z4.string().default("inbox").optional(),
-          limit: z4.number().int().positive().max(100).optional(),
-          unreadOnly: z4.boolean().optional(),
-          skip: z4.number().int().min(0).optional()
+        inputSchema: z5.object({
+          account: z5.string().email(),
+          folder: z5.string().default("inbox").optional(),
+          limit: z5.number().int().positive().max(100).optional(),
+          unreadOnly: z5.boolean().optional(),
+          skip: z5.number().int().min(0).optional()
         }),
         outputSchema: emailListOutputSchema
       },
@@ -17118,15 +17374,16 @@ function registerBrowseTools(server, ctx) {
       }
     );
   }
+  registerNewEmailTool(server, { store, registry, tools });
   if (shouldRegister("search_emails", tools)) {
     server.registerTool(
       "search_emails",
       {
         description: "Search emails by free-text query (KQL on Outlook). Returns lightweight summaries.",
-        inputSchema: z4.object({
-          account: z4.string().email(),
-          query: z4.string().min(1),
-          limit: z4.number().int().positive().max(100).optional()
+        inputSchema: z5.object({
+          account: z5.string().email(),
+          query: z5.string().min(1),
+          limit: z5.number().int().positive().max(100).optional()
         }),
         outputSchema: searchEmailsOutputSchema
       },
@@ -17148,31 +17405,31 @@ function registerBrowseTools(server, ctx) {
       }
     );
   }
-  const readEmailOutputSchema = z4.object({
-    id: z4.string(),
-    subject: z4.string(),
+  const readEmailOutputSchema = z5.object({
+    id: z5.string(),
+    subject: z5.string(),
     from: emailAddrOutputSchema.optional(),
-    to: z4.array(emailAddrOutputSchema).optional(),
-    cc: z4.array(emailAddrOutputSchema).optional(),
-    bcc: z4.array(emailAddrOutputSchema).optional(),
-    receivedAt: z4.string().optional(),
-    preview: z4.string().optional(),
-    isRead: z4.boolean().optional(),
-    hasAttachments: z4.boolean().optional(),
-    folder: z4.string().optional(),
-    attachments: z4.array(attachmentMetaOutputSchema).optional(),
-    body: z4.string(),
-    bodyFormat: z4.enum(["markdown", "html", "text"])
+    to: z5.array(emailAddrOutputSchema).optional(),
+    cc: z5.array(emailAddrOutputSchema).optional(),
+    bcc: z5.array(emailAddrOutputSchema).optional(),
+    receivedAt: z5.string().optional(),
+    preview: z5.string().optional(),
+    isRead: z5.boolean().optional(),
+    hasAttachments: z5.boolean().optional(),
+    folder: z5.string().optional(),
+    attachments: z5.array(attachmentMetaOutputSchema).optional(),
+    body: z5.string(),
+    bodyFormat: z5.enum(["markdown", "html", "text"])
   });
   if (shouldRegister("read_email", tools)) {
     server.registerTool(
       "read_email",
       {
         description: "Fetch a single email with full body and recipients by id. Body is returned as `body` with `bodyFormat` indicating the format. Default format is 'markdown' \u2014 HTML is automatically converted to save context tokens.",
-        inputSchema: z4.object({
-          account: z4.string().email(),
-          id: z4.string().min(1),
-          format: z4.enum(["markdown", "html", "text"]).default("markdown").optional().describe(
+        inputSchema: z5.object({
+          account: z5.string().email(),
+          id: z5.string().min(1),
+          format: z5.enum(["markdown", "html", "text"]).default("markdown").optional().describe(
             "Output body format. 'markdown' converts HTML to Markdown (default), 'html' returns the raw HTML, 'text' returns plain text."
           )
         }),
@@ -17207,20 +17464,20 @@ function registerBrowseTools(server, ctx) {
       }
     );
   }
-  const readAttachmentOutputSchema = z4.object({
-    name: z4.string(),
-    contentType: z4.string().optional(),
-    path: z4.string()
+  const readAttachmentOutputSchema = z5.object({
+    name: z5.string(),
+    contentType: z5.string().optional(),
+    path: z5.string()
   });
   if (shouldRegister("read_attachment", tools)) {
     server.registerTool(
       "read_attachment",
       {
         description: "Download an email attachment to a temporary file and return its path. Use messageId and attachmentId from a prior read_email call.",
-        inputSchema: z4.object({
-          account: z4.string().email(),
-          messageId: z4.string().min(1),
-          attachmentId: z4.string().min(1)
+        inputSchema: z5.object({
+          account: z5.string().email(),
+          messageId: z5.string().min(1),
+          attachmentId: z5.string().min(1)
         }),
         outputSchema: readAttachmentOutputSchema
       },
@@ -17242,22 +17499,22 @@ function registerBrowseTools(server, ctx) {
 }
 
 // src/tools/folders.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function registerFolderTools(server, ctx) {
   const { registry, tools } = ctx;
-  const listFoldersOutputSchema = z5.object({
-    account: z5.string(),
-    count: z5.number(),
-    items: z5.array(folderInfoOutputSchema)
+  const listFoldersOutputSchema = z6.object({
+    account: z6.string(),
+    count: z6.number(),
+    items: z6.array(folderInfoOutputSchema)
   });
   if (shouldRegister("list_folders", tools)) {
     server.registerTool(
       "list_folders",
       {
         description: "List available mail folders. Returns top-level folders by default, or child folders of the given parent when `parentFolderId` is provided.",
-        inputSchema: z5.object({
-          account: z5.string().email(),
-          parentFolderId: z5.string().optional().describe(
+        inputSchema: z6.object({
+          account: z6.string().email(),
+          parentFolderId: z6.string().optional().describe(
             "When provided, lists child folders of this folder. When omitted, lists top-level folders (children of the root)."
           )
         }),
@@ -17281,8 +17538,8 @@ function registerFolderTools(server, ctx) {
       }
     );
   }
-  const createFolderOutputSchema = z5.object({
-    created: z5.literal(true),
+  const createFolderOutputSchema = z6.object({
+    created: z6.literal(true),
     folder: folderInfoOutputSchema
   });
   if (shouldRegister("create_folder", tools)) {
@@ -17290,10 +17547,10 @@ function registerFolderTools(server, ctx) {
       "create_folder",
       {
         description: "Create a new mail folder. Creates under the root folder by default, or under the specified parent when `parentFolderId` is provided. Disabled in --read-only mode.",
-        inputSchema: z5.object({
-          account: z5.string().email(),
-          displayName: z5.string().min(1).describe("Name of the new folder"),
-          parentFolderId: z5.string().optional().describe(
+        inputSchema: z6.object({
+          account: z6.string().email(),
+          displayName: z6.string().min(1).describe("Name of the new folder"),
+          parentFolderId: z6.string().optional().describe(
             "When provided, creates the folder as a child of this folder. When omitted, creates under the root folder."
           )
         }),
@@ -17314,18 +17571,18 @@ function registerFolderTools(server, ctx) {
       }
     );
   }
-  const deleteFolderOutputSchema = z5.object({
-    deleted: z5.literal(true),
-    id: z5.string()
+  const deleteFolderOutputSchema = z6.object({
+    deleted: z6.literal(true),
+    id: z6.string()
   });
   if (shouldRegister("delete_folder", tools)) {
     server.registerTool(
       "delete_folder",
       {
         description: "Delete a mail folder by ID. Disabled in --read-only mode.",
-        inputSchema: z5.object({
-          account: z5.string().email(),
-          folderId: z5.string().min(1).describe("ID of the folder to delete")
+        inputSchema: z6.object({
+          account: z6.string().email(),
+          folderId: z6.string().min(1).describe("ID of the folder to delete")
         }),
         outputSchema: deleteFolderOutputSchema
       },
@@ -17341,8 +17598,8 @@ function registerFolderTools(server, ctx) {
       }
     );
   }
-  const renameFolderOutputSchema = z5.object({
-    renamed: z5.literal(true),
+  const renameFolderOutputSchema = z6.object({
+    renamed: z6.literal(true),
     folder: folderInfoOutputSchema
   });
   if (shouldRegister("rename_folder", tools)) {
@@ -17350,10 +17607,10 @@ function registerFolderTools(server, ctx) {
       "rename_folder",
       {
         description: "Rename an existing mail folder. Disabled in --read-only mode.",
-        inputSchema: z5.object({
-          account: z5.string().email(),
-          folderId: z5.string().min(1).describe("ID of the folder to rename"),
-          newName: z5.string().min(1).describe("New display name for the folder")
+        inputSchema: z6.object({
+          account: z6.string().email(),
+          folderId: z6.string().min(1).describe("ID of the folder to rename"),
+          newName: z6.string().min(1).describe("New display name for the folder")
         }),
         outputSchema: renameFolderOutputSchema
       },
@@ -17376,7 +17633,7 @@ function registerFolderTools(server, ctx) {
 }
 
 // src/tools/organize.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function registerOrganizeTools(server, ctx) {
   const { registry, tools } = ctx;
   async function moveToWellKnown(args, destination, resultKey) {
@@ -17392,13 +17649,13 @@ function registerOrganizeTools(server, ctx) {
     const data = { marked: true, id: args.id, isRead };
     return ok(data, data);
   }
-  const archiveMoveSchema = z6.object({
-    account: z6.string().email(),
-    id: z6.string().min(1).describe("Message ID to move")
+  const archiveMoveSchema = z7.object({
+    account: z7.string().email(),
+    id: z7.string().min(1).describe("Message ID to move")
   });
-  const archiveOutputSchema = z6.object({
-    archived: z6.literal(true),
-    id: z6.string()
+  const archiveOutputSchema = z7.object({
+    archived: z7.literal(true),
+    id: z7.string()
   });
   if (shouldRegister("archive_email", tools)) {
     server.registerTool(
@@ -17417,9 +17674,9 @@ function registerOrganizeTools(server, ctx) {
       }
     );
   }
-  const trashOutputSchema = z6.object({
-    trashed: z6.literal(true),
-    id: z6.string()
+  const trashOutputSchema = z7.object({
+    trashed: z7.literal(true),
+    id: z7.string()
   });
   if (shouldRegister("trash_email", tools)) {
     server.registerTool(
@@ -17438,20 +17695,20 @@ function registerOrganizeTools(server, ctx) {
       }
     );
   }
-  const moveEmailOutputSchema = z6.object({
-    moved: z6.literal(true),
-    id: z6.string(),
-    destination: z6.string()
+  const moveEmailOutputSchema = z7.object({
+    moved: z7.literal(true),
+    id: z7.string(),
+    destination: z7.string()
   });
   if (shouldRegister("move_email", tools)) {
     server.registerTool(
       "move_email",
       {
         description: "Move a message to any folder by well-known name (e.g. 'inbox', 'drafts', 'junkemail', 'sentitems', 'outbox') or custom folder ID. Disabled in --read-only mode.",
-        inputSchema: z6.object({
-          account: z6.string().email(),
-          id: z6.string().min(1).describe("Message ID to move"),
-          destination: z6.string().min(1).describe(
+        inputSchema: z7.object({
+          account: z7.string().email(),
+          id: z7.string().min(1).describe("Message ID to move"),
+          destination: z7.string().min(1).describe(
             "Destination folder \u2014 a well-known folder name ('archive', 'deleteditems', 'inbox', 'drafts', 'junkemail', 'sentitems', 'outbox') or a raw folder ID."
           )
         }),
@@ -17473,14 +17730,14 @@ function registerOrganizeTools(server, ctx) {
       }
     );
   }
-  const markReadInputSchema = z6.object({
-    account: z6.string().email(),
-    id: z6.string().min(1).describe("Message ID to mark as read")
+  const markReadInputSchema = z7.object({
+    account: z7.string().email(),
+    id: z7.string().min(1).describe("Message ID to mark as read")
   });
-  const markReadOutputSchema = z6.object({
-    marked: z6.literal(true),
-    id: z6.string(),
-    isRead: z6.boolean()
+  const markReadOutputSchema = z7.object({
+    marked: z7.literal(true),
+    id: z7.string(),
+    isRead: z7.boolean()
   });
   if (shouldRegister("mark_read", tools)) {
     server.registerTool(
@@ -17519,7 +17776,7 @@ function registerOrganizeTools(server, ctx) {
 }
 
 // src/tools/compose.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { readFileSync } from "fs";
 import { basename, extname } from "path";
 function registerComposeTools(server, ctx) {
@@ -17549,32 +17806,32 @@ function registerComposeTools(server, ctx) {
     ".mp3": "audio/mpeg",
     ".mp4": "video/mp4"
   };
-  const sendEmailSchema = z7.object({
-    account: z7.string().email(),
-    to: z7.array(emailAddrSchema).min(1),
-    cc: z7.array(emailAddrSchema).optional(),
-    bcc: z7.array(emailAddrSchema).optional(),
-    subject: z7.string(),
-    body: z7.string(),
-    format: z7.enum(["html", "markdown"]).describe(
+  const sendEmailSchema = z8.object({
+    account: z8.string().email(),
+    to: z8.array(emailAddrSchema).min(1),
+    cc: z8.array(emailAddrSchema).optional(),
+    bcc: z8.array(emailAddrSchema).optional(),
+    subject: z8.string(),
+    body: z8.string(),
+    format: z8.enum(["html", "markdown"]).describe(
       "Body format. 'html' sends the body as-is (must be valid HTML). 'markdown' converts the body from Markdown to HTML for clean rendering on the recipient side."
     ),
-    include_signature: z7.boolean().describe(
+    include_signature: z8.boolean().describe(
       "Whether to append the account's saved HTML signature to the email. If true, don't include a signature in the body param to avoid double signature. Returns an error if true but no signature is configured for this account."
     ),
-    inReplyTo: z7.union([z7.string(), z7.literal(false)]).describe(
+    inReplyTo: z8.union([z8.string(), z8.literal(false)]).describe(
       "Message ID to reply to. When set, sends as a threaded reply which includes the quoted thread history automatically. Set to `false` for a new email (not a reply)."
     ),
-    replyAll: z7.boolean().default(false).optional().describe(
+    replyAll: z8.boolean().default(false).optional().describe(
       "When true and `inReplyTo` is set, reply to all recipients instead of just the sender."
     ),
-    forwardMessageId: z7.string().optional().describe(
+    forwardMessageId: z8.string().optional().describe(
       "Message ID to forward. When set, sends as a forward of the specified message, preserving the original content. Mutually exclusive with `inReplyTo`."
     ),
-    attachments: z7.array(
-      z7.object({
-        filePath: z7.string().min(1).describe("Absolute path to a local file"),
-        name: z7.string().optional().describe(
+    attachments: z8.array(
+      z8.object({
+        filePath: z8.string().min(1).describe("Absolute path to a local file"),
+        name: z8.string().optional().describe(
           "Attachment filename. Defaults to the file's basename."
         )
       })
@@ -17637,8 +17894,8 @@ function registerComposeTools(server, ctx) {
     }
   }
   const sendEmailOutputSchema = {
-    sent: z7.literal(true),
-    id: z7.string()
+    sent: z8.literal(true),
+    id: z8.string()
   };
   if (shouldRegister("send_email", tools)) {
     server.registerTool(
@@ -17657,9 +17914,9 @@ function registerComposeTools(server, ctx) {
     );
   }
   const draftEmailOutputSchema = {
-    draft: z7.literal(true),
-    id: z7.string(),
-    draftHtml: z7.string().optional()
+    draft: z8.literal(true),
+    id: z8.string(),
+    draftHtml: z8.string().optional()
   };
   if (shouldRegister("draft_email", tools)) {
     server.registerTool(
@@ -17677,38 +17934,38 @@ function registerComposeTools(server, ctx) {
       )
     );
   }
-  const editDraftSchema = z7.object({
-    account: z7.string().email(),
-    id: z7.string().min(1).describe("Draft message ID to edit"),
-    to: z7.array(emailAddrSchema).optional(),
-    cc: z7.array(emailAddrSchema).optional(),
-    bcc: z7.array(emailAddrSchema).optional(),
-    subject: z7.string().optional(),
-    body: z7.string().optional(),
-    format: z7.enum(["html", "markdown"]).optional().describe(
+  const editDraftSchema = z8.object({
+    account: z8.string().email(),
+    id: z8.string().min(1).describe("Draft message ID to edit"),
+    to: z8.array(emailAddrSchema).optional(),
+    cc: z8.array(emailAddrSchema).optional(),
+    bcc: z8.array(emailAddrSchema).optional(),
+    subject: z8.string().optional(),
+    body: z8.string().optional(),
+    format: z8.enum(["html", "markdown"]).optional().describe(
       "Body format. Only meaningful when `body` is also provided. 'html' sends the body as-is (must be valid HTML). 'markdown' converts the body from Markdown to HTML for clean rendering on the recipient side."
     ),
-    include_signature: z7.boolean().optional().describe(
+    include_signature: z8.boolean().optional().describe(
       "Whether to re-apply the account's saved HTML signature to the body. If true, don't include a signature in the body param. Only meaningful when `body` is also provided. Returns an error if true but no signature is configured for this account."
     ),
-    new_attachments: z7.array(
-      z7.object({
-        filePath: z7.string().min(1).describe("Absolute path to a local file"),
-        name: z7.string().optional().describe(
+    new_attachments: z8.array(
+      z8.object({
+        filePath: z8.string().min(1).describe("Absolute path to a local file"),
+        name: z8.string().optional().describe(
           "Attachment filename. Defaults to the file's basename."
         )
       })
     ).optional().describe(
       "New file attachments to add to the draft. The server reads the files from disk and base64-encodes them automatically."
     ),
-    remove_attachments: z7.array(z7.string().min(1)).optional().describe(
+    remove_attachments: z8.array(z8.string().min(1)).optional().describe(
       "Attachment IDs to remove from the draft. Get attachment IDs from read_email."
     )
   });
   const editDraftOutputSchema = {
-    edited: z7.literal(true),
-    id: z7.string(),
-    draftHtml: z7.string().optional()
+    edited: z8.literal(true),
+    id: z8.string(),
+    draftHtml: z8.string().optional()
   };
   if (shouldRegister("edit_draft", tools)) {
     server.registerTool(
@@ -17800,8 +18057,8 @@ function registerComposeTools(server, ctx) {
     );
   }
   const sendDraftOutputSchema = {
-    sent: z7.literal(true),
-    id: z7.string()
+    sent: z8.literal(true),
+    id: z8.string()
   };
   if (shouldRegister("send_draft", tools)) {
     server.registerTool(
@@ -17809,8 +18066,8 @@ function registerComposeTools(server, ctx) {
       {
         description: "Send an existing draft email by ID. Use this with draft IDs returned by `draft_email` or `edit_draft`. Disabled in --read-only mode.",
         inputSchema: {
-          account: z7.string().email(),
-          id: z7.string().min(1).describe("Draft message ID to send")
+          account: z8.string().email(),
+          id: z8.string().min(1).describe("Draft message ID to send")
         },
         outputSchema: sendDraftOutputSchema
       },
@@ -17832,7 +18089,7 @@ function registerComposeTools(server, ctx) {
 function registerTools(server, opts) {
   const { store, registry, tools } = opts;
   registerAccountTools(server, { store, registry, tools });
-  registerBrowseTools(server, { registry, tools });
+  registerBrowseTools(server, { store, registry, tools });
   registerFolderTools(server, { registry, tools });
   registerOrganizeTools(server, { registry, tools });
   registerComposeTools(server, { store, registry, tools });
@@ -17841,7 +18098,7 @@ function registerTools(server, opts) {
 // package.json
 var package_default = {
   name: "hypermail-mcp",
-  version: "0.7.7",
+  version: "0.7.9",
   description: "Unified email MCP server \u2014 operate any inbox (Outlook now, IMAP/Gmail later) by passing an email address.",
   type: "module",
   bin: {
@@ -17913,193 +18170,6 @@ var package_default = {
 // src/version.ts
 var VERSION = package_default.version;
 
-// src/watcher/webhook.ts
-async function postWebhook(email, config) {
-  if (!config.webhook) return false;
-  const { url, retry } = config.webhook;
-  const maxAttempts = retry.maxAttempts;
-  const baseDelayMs = retry.baseDelayMs;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    if (attempt > 0) {
-      const delay = baseDelayMs * 2 ** (attempt - 1);
-      await sleep(delay);
-    }
-    try {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(email)
-      });
-      if (res.ok) return true;
-      console.error(
-        `[hypermail-watch] webhook POST ${email.id} attempt ${attempt + 1}/${maxAttempts}: HTTP ${res.status}`
-      );
-    } catch (err) {
-      const code = err.code ?? "";
-      console.error(
-        `[hypermail-watch] webhook POST ${email.id} attempt ${attempt + 1}/${maxAttempts}: ${code || String(err)}`
-      );
-    }
-  }
-  console.error(
-    `[hypermail-watch] webhook delivery failed after ${maxAttempts} retries for ${email.id}`
-  );
-  return false;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/watcher/script.ts
-import { spawn } from "child_process";
-async function runNotifyCommand(email, config) {
-  if (!config.notifyCommand) return false;
-  const { command, timeoutMs, retry } = config.notifyCommand;
-  const maxAttempts = retry.maxAttempts;
-  const baseDelayMs = retry.baseDelayMs;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    if (attempt > 0) {
-      const delay = baseDelayMs * 2 ** (attempt - 1);
-      await sleep2(delay);
-    }
-    try {
-      const ok2 = await spawnWithTimeout(
-        command,
-        JSON.stringify(email),
-        timeoutMs
-      );
-      if (ok2) return true;
-      console.error(
-        `[hypermail-watch] notify command ${email.id} attempt ${attempt + 1}/${maxAttempts}: non-zero exit code`
-      );
-    } catch (err) {
-      console.error(
-        `[hypermail-watch] notify command ${email.id} attempt ${attempt + 1}/${maxAttempts}: ${String(err)}`
-      );
-    }
-  }
-  console.error(
-    `[hypermail-watch] notify command delivery failed after ${maxAttempts} retries for ${email.id}`
-  );
-  return false;
-}
-function spawnWithTimeout(command, stdinData, timeoutMs) {
-  return new Promise((resolve) => {
-    const child = spawn(command, {
-      shell: true,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stderr = "";
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString("utf-8");
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      if (stderr) {
-        console.error(`[hypermail-watch] notify command timed out after ${timeoutMs}ms. stderr:
-${stderr}`);
-      }
-      resolve(false);
-    }, timeoutMs);
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (stderr && code !== 0) {
-        console.error(`[hypermail-watch] notify command stderr:
-${stderr}`);
-      }
-      resolve(code === 0);
-    });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      console.error(`[hypermail-watch] notify command spawn error: ${err.message}`);
-      resolve(false);
-    });
-    child.stdin?.end(stdinData);
-  });
-}
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/watcher/manager.ts
-var WatcherManager = class {
-  constructor(store, registry, config) {
-    this.store = store;
-    this.registry = registry;
-    this.config = config;
-  }
-  store;
-  registry;
-  config;
-  intervalId = null;
-  /** Start the poll loop. Fires immediately on the first tick, then every
-   *  `pollIntervalSeconds`. Safe to call multiple times — subsequent calls
-   *  are no-ops. */
-  start() {
-    if (this.intervalId !== null) return;
-    this.poll();
-    this.intervalId = setInterval(
-      () => this.poll(),
-      this.config.pollIntervalSeconds * 1e3
-    );
-  }
-  /** Stop the poll loop and release the interval. Safe to call when already
-   *  stopped. */
-  stop() {
-    if (this.intervalId !== null) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-  }
-  // ── private ──
-  async poll() {
-    const accounts = this.store.listAccounts();
-    for (const acct of accounts) {
-      try {
-        await this.pollAccount(acct.email);
-      } catch (err) {
-        console.error(
-          `[hypermail-watch] poll failed for ${acct.email}:`,
-          err
-        );
-      }
-    }
-  }
-  async pollAccount(email) {
-    const { provider, account } = this.registry.resolveByEmail(email);
-    const result = await provider.listEmails(account, {
-      folder: "inbox",
-      limit: 50
-    });
-    const knownIds = [...account.lastSeenIds ?? []];
-    const newEmails = result.items.filter((e) => !knownIds.includes(e.id));
-    if (newEmails.length === 0) return;
-    for (const summary of newEmails) {
-      try {
-        const full = await provider.readEmail(account, summary.id);
-        await this.emit(full);
-        knownIds.unshift(summary.id);
-      } catch (err) {
-        console.error(
-          `[hypermail-watch] emission failed for ${email}/${summary.id}:`,
-          err
-        );
-      }
-    }
-    const capped = knownIds.slice(0, 200);
-    await this.store.upsertAccount({ ...account, lastSeenIds: capped });
-  }
-  async emit(full) {
-    await postWebhook(full, this.config);
-    runNotifyCommand(full, this.config).catch((err) => {
-      console.error(
-        `[hypermail-watch] notify command unhandled error for ${full.id}:`,
-        err
-      );
-    });
-  }
-};
-
 // src/config/load.ts
 var ENV_DATA_DIR = "HYPERMAIL_DATA_DIR";
 var ENV_KEY = "HYPERMAIL_KEY";
@@ -18113,22 +18183,9 @@ var ENV_OUTLOOK_TENANT_ID = "HYPERMAIL_OUTLOOK_TENANT_ID";
 var ENV_GMAIL_CLIENT_ID = "HYPERMAIL_GMAIL_CLIENT_ID";
 var ENV_GMAIL_CLIENT_SECRET = "HYPERMAIL_GMAIL_CLIENT_SECRET";
 var ENV_GMAIL_REDIRECT_URI = "HYPERMAIL_GMAIL_REDIRECT_URI";
-var ENV_WATCH_ENABLED = "HYPERMAIL_WATCH_ENABLED";
-var ENV_WATCH_POLL_SECONDS = "HYPERMAIL_WATCH_POLL_SECONDS";
-var ENV_WATCH_WEBHOOK_URL = "HYPERMAIL_WATCH_WEBHOOK_URL";
-var ENV_WATCH_WEBHOOK_RETRY_ATTEMPTS = "HYPERMAIL_WATCH_WEBHOOK_RETRY_ATTEMPTS";
-var ENV_WATCH_WEBHOOK_RETRY_DELAY_MS = "HYPERMAIL_WATCH_WEBHOOK_RETRY_DELAY_MS";
-var ENV_WATCH_NOTIFY_COMMAND = "HYPERMAIL_WATCH_NOTIFY_COMMAND";
-var ENV_WATCH_NOTIFY_TIMEOUT_MS = "HYPERMAIL_WATCH_NOTIFY_TIMEOUT_MS";
-var ENV_WATCH_NOTIFY_RETRY_ATTEMPTS = "HYPERMAIL_WATCH_NOTIFY_RETRY_ATTEMPTS";
-var ENV_WATCH_NOTIFY_RETRY_DELAY_MS = "HYPERMAIL_WATCH_NOTIFY_RETRY_DELAY_MS";
 var DEFAULT_TRANSPORT = "stdio";
 var DEFAULT_HTTP_PORT = 3e3;
 var DEFAULT_HTTP_HOST = "127.0.0.1";
-var DEFAULT_WATCH_POLL_SECONDS = 10;
-var DEFAULT_RETRY_ATTEMPTS = 5;
-var DEFAULT_RETRY_DELAY_MS = 1e3;
-var DEFAULT_NOTIFY_TIMEOUT_MS = 3e4;
 function envRaw(name) {
   return process.env[name];
 }
@@ -18138,14 +18195,6 @@ function optionalEnvString(name) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
-function parseBoolEnv(name) {
-  const value = envRaw(name);
-  if (value === void 0) return void 0;
-  const lower = value.trim().toLowerCase();
-  if (lower === "true") return true;
-  if (lower === "false") return false;
-  throw new Error(`${name} must be either "true" or "false"`);
-}
 function parseTransportEnv() {
   const value = envRaw(ENV_TRANSPORT);
   if (value === void 0) return void 0;
@@ -18163,15 +18212,6 @@ function parsePositiveInteger(value) {
   const parsed = Number(trimmed);
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
 }
-function parsePositiveIntegerEnv(name, defaultValue) {
-  const value = envRaw(name);
-  if (value === void 0) return defaultValue;
-  const parsed = parsePositiveInteger(value);
-  if (parsed === void 0) {
-    throw new Error(`${name} must be a positive integer`);
-  }
-  return parsed;
-}
 function parseStringArray(value) {
   if (value === void 0) return void 0;
   const trimmed = value.trim();
@@ -18189,17 +18229,6 @@ function validateToolNames(toolNames, envName) {
     }
   }
 }
-function validateWebhookUrl(raw) {
-  try {
-    const url = new URL(raw);
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      throw new Error("unsupported protocol");
-    }
-    return raw;
-  } catch {
-    throw new Error(`${ENV_WATCH_WEBHOOK_URL} must be a valid http(s) URL`);
-  }
-}
 function resolveHttpConfig(transport, cliOverrides, warnings) {
   const portSource = cliOverrides.port !== void 0 ? "--port" : ENV_HTTP_PORT;
   const rawPort = cliOverrides.port ?? envRaw(ENV_HTTP_PORT);
@@ -18263,68 +18292,12 @@ function resolveProvidersConfig() {
   }
   return providers;
 }
-function resolveRetryConfig(attemptsEnv, delayEnv) {
-  return {
-    maxAttempts: parsePositiveIntegerEnv(attemptsEnv, DEFAULT_RETRY_ATTEMPTS),
-    baseDelayMs: parsePositiveIntegerEnv(delayEnv, DEFAULT_RETRY_DELAY_MS)
-  };
-}
-function resolveWatchConfig() {
-  const enabled = parseBoolEnv(ENV_WATCH_ENABLED) ?? false;
-  if (!enabled) return void 0;
-  const pollIntervalSeconds = parsePositiveIntegerEnv(
-    ENV_WATCH_POLL_SECONDS,
-    DEFAULT_WATCH_POLL_SECONDS
-  );
-  const webhookUrl = optionalEnvString(ENV_WATCH_WEBHOOK_URL);
-  let webhook;
-  if (webhookUrl) {
-    webhook = {
-      url: validateWebhookUrl(webhookUrl),
-      retry: resolveRetryConfig(
-        ENV_WATCH_WEBHOOK_RETRY_ATTEMPTS,
-        ENV_WATCH_WEBHOOK_RETRY_DELAY_MS
-      )
-    };
-  }
-  const rawNotifyCommand = envRaw(ENV_WATCH_NOTIFY_COMMAND);
-  let notifyCommand;
-  if (rawNotifyCommand !== void 0) {
-    const command = rawNotifyCommand.trim();
-    if (!command) {
-      throw new Error(`${ENV_WATCH_NOTIFY_COMMAND} must not be empty when watch is enabled`);
-    }
-    notifyCommand = {
-      command,
-      timeoutMs: parsePositiveIntegerEnv(
-        ENV_WATCH_NOTIFY_TIMEOUT_MS,
-        DEFAULT_NOTIFY_TIMEOUT_MS
-      ),
-      retry: resolveRetryConfig(
-        ENV_WATCH_NOTIFY_RETRY_ATTEMPTS,
-        ENV_WATCH_NOTIFY_RETRY_DELAY_MS
-      )
-    };
-  }
-  if (!webhook && !notifyCommand) {
-    throw new Error(
-      `${ENV_WATCH_ENABLED}=true requires ${ENV_WATCH_WEBHOOK_URL} or ${ENV_WATCH_NOTIFY_COMMAND}`
-    );
-  }
-  return {
-    enabled: true,
-    pollIntervalSeconds,
-    webhook,
-    notifyCommand
-  };
-}
 function loadConfig(cliOverrides = {}) {
   const warnings = [];
   const transport = cliOverrides.transport ?? parseTransportEnv() ?? DEFAULT_TRANSPORT;
   const http = resolveHttpConfig(transport, cliOverrides, warnings);
   const tools = resolveToolsConfig();
   const providers = resolveProvidersConfig();
-  const watch = resolveWatchConfig();
   const dataDir = cliOverrides.dataDir ?? optionalEnvString(ENV_DATA_DIR);
   if (!optionalEnvString(ENV_KEY)) {
     warnings.push(
@@ -18337,8 +18310,7 @@ function loadConfig(cliOverrides = {}) {
       transport,
       http,
       tools,
-      providers,
-      watch
+      providers
     },
     warnings
   };
@@ -18353,6 +18325,7 @@ var KNOWN_TOOLS = [
   "set_account_settings",
   "remove_account",
   "list_emails",
+  "get_new_emails",
   "search_emails",
   "read_email",
   "read_attachment",
@@ -18386,14 +18359,6 @@ async function startServer(opts) {
   const store = await AccountStore.open({ dataDir: config.dataDir });
   const registry = buildRegistry({ store, providers: config.providers });
   const tools = resolveTools(config);
-  let watcher;
-  if (config.watch?.enabled) {
-    watcher = new WatcherManager(store, registry, config.watch);
-    watcher.start();
-    const stop = () => watcher?.stop();
-    process.on("SIGTERM", stop);
-    process.on("SIGINT", stop);
-  }
   const createServer = () => {
     const s = new McpServer(
       { name: "hypermail-mcp", version: VERSION },
@@ -18598,17 +18563,6 @@ Provider environment variables:
   HYPERMAIL_GMAIL_CLIENT_SECRET
   HYPERMAIL_GMAIL_REDIRECT_URI
 
-Watcher environment variables:
-  HYPERMAIL_WATCH_ENABLED=true|false
-  HYPERMAIL_WATCH_POLL_SECONDS
-  HYPERMAIL_WATCH_WEBHOOK_URL
-  HYPERMAIL_WATCH_WEBHOOK_RETRY_ATTEMPTS
-  HYPERMAIL_WATCH_WEBHOOK_RETRY_DELAY_MS
-  HYPERMAIL_WATCH_NOTIFY_COMMAND
-  HYPERMAIL_WATCH_NOTIFY_TIMEOUT_MS
-  HYPERMAIL_WATCH_NOTIFY_RETRY_ATTEMPTS
-  HYPERMAIL_WATCH_NOTIFY_RETRY_DELAY_MS
-
 Example:
   HYPERMAIL_TRANSPORT=http \\
   HYPERMAIL_HTTP_PORT=8080 \\