@chrischall/office-outlook-mcp 0.10.1 → 0.11.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "MCP server for Outlook / Microsoft 365 — mail, calendar, contacts and tasks via natural language",
-    "version": "0.10.1"
+    "version": "0.11.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "Outlook (Microsoft 365)",
       "source": "./",
       "description": "MCP server for Outlook / Microsoft 365 — triage unread mail, reply, answer meeting invites and schedule meetings, plus folders, calendar, contacts and tasks, with confirmation before anything is sent",
-      "version": "0.10.1",
+      "version": "0.11.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "office-outlook-mcp",
   "displayName": "Outlook (Microsoft 365)",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Outlook / Microsoft 365 for Claude — triage unread mail, reply, answer meeting invites and schedule meetings, plus folders, calendar, contacts and tasks, with confirmation before anything is sent, using your signed-in browser session",
   "author": {
     "name": "Chris Hall",

package/README.md

@@ -134,14 +134,16 @@ Everything is optional — with nothing set, the server captures from the browse
 `outlook_list_categories`, `outlook_list_tasks`, `outlook_list_rules`
 
 **Write** (ask you to confirm first — see [Confirmations](#confirmations)) —
-`outlook_send_message`, `outlook_create_draft`, `outlook_mark_read`,
+`outlook_send_message`, `outlook_create_draft`, `outlook_update_draft`, `outlook_send_draft`, `outlook_mark_read`,
 `outlook_update_message`, `outlook_move_message`, `outlook_create_event`,
 `outlook_update_event`, `outlook_respond_to_invite`, `outlook_delete_event`,
 `outlook_reply`, `outlook_create_rule`, `outlook_update_rule`,
-`outlook_delete_rule`, `outlook_set_auto_reply`.
+`outlook_delete_rule`, `outlook_set_auto_reply`, `outlook_create_folder`,
+`outlook_update_folder` (rename or move), `outlook_delete_folder`
+(permanent: the folder does not go to Deleted Items).
 Some skip the confirmation because nothing reaches anyone else:
-`outlook_create_draft` (the draft stays in Drafts until you send it from
-Outlook), `outlook_reply` with `draftOnly: true` (the reply stays in Drafts),
+`outlook_create_draft` (the draft stays in Drafts until you send it with
+`outlook_send_draft` or from Outlook), `outlook_create_folder` (an empty folder is easily deleted), `outlook_reply` with `draftOnly: true` (the reply stays in Drafts),
 `outlook_respond_to_invite` with `sendResponse: false`, and
 `outlook_delete_event` on your own appointment with no attendees or on a
 meeting the organizer already cancelled (in each, only your calendar

package/dist/bundle.js

@@ -10588,8 +10588,8 @@ var init_pt = __esm({
           case "not_multiple_of":
             return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
           case "unrecognized_keys": {
-            const plural2 = issue2.keys.length > 1 ? "s" : "";
-            return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
+            const plural3 = issue2.keys.length > 1 ? "s" : "";
+            return `Chave${plural3} inv\xE1lida${plural3}: ${joinValues(issue2.keys, ", ")}`;
           }
           case "invalid_key":
             return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
@@ -10739,8 +10739,8 @@ var init_pt_BR = __esm({
           case "not_multiple_of":
             return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
           case "unrecognized_keys": {
-            const plural2 = issue2.keys.length > 1 ? "s" : "";
-            return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
+            const plural3 = issue2.keys.length > 1 ? "s" : "";
+            return `Chave${plural3} inv\xE1lida${plural3}: ${joinValues(issue2.keys, ", ")}`;
           }
           case "invalid_key":
             return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
@@ -37164,11 +37164,11 @@ async function confirmWrite(ctx, options) {
   }
   const query = request?.query ? Object.fromEntries(Object.entries(request.query).filter(([, v]) => v !== void 0)) : void 0;
   const hasQuery = query !== void 0 && Object.keys(query).length > 0;
-  const shown = willSend !== void 0 ? willSend : request?.body !== void 0 ? request.body : payload;
+  const shown3 = willSend !== void 0 ? willSend : request?.body !== void 0 ? request.body : payload;
   const preview = {
     ...summary === void 0 ? {} : { action: summary },
     ...request === void 0 ? {} : { method: request.method, path: request.path },
-    ...shown === void 0 ? {} : { willSend: shown },
+    ...shown3 === void 0 ? {} : { willSend: shown3 },
     ...hasQuery ? { willSendQuery: query } : {},
     ...extra
   };
@@ -39293,7 +39293,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     PACKAGE_NAME = "office-outlook-mcp";
-    VERSION = "0.10.1";
+    VERSION = "0.11.0";
   }
 });
 
@@ -60041,20 +60041,20 @@ var require_ms = __commonJS({
     function fmtLong(ms) {
       var msAbs = Math.abs(ms);
       if (msAbs >= d) {
-        return plural2(ms, msAbs, d, "day");
+        return plural3(ms, msAbs, d, "day");
       }
       if (msAbs >= h) {
-        return plural2(ms, msAbs, h, "hour");
+        return plural3(ms, msAbs, h, "hour");
       }
       if (msAbs >= m) {
-        return plural2(ms, msAbs, m, "minute");
+        return plural3(ms, msAbs, m, "minute");
       }
       if (msAbs >= s) {
-        return plural2(ms, msAbs, s, "second");
+        return plural3(ms, msAbs, s, "second");
       }
       return ms + " ms";
     }
-    function plural2(ms, msAbs, n, name3) {
+    function plural3(ms, msAbs, n, name3) {
       var isPlural = msAbs >= n * 1.5;
       return Math.round(ms / n) + " " + name3 + (isPlural ? "s" : "");
     }
@@ -68629,12 +68629,12 @@ var TITLE_FLOOR = 24;
 var cut = (s, n) => s.length > n ? `${s.slice(0, Math.max(n - 1, 0))}\u2026` : s;
 function briefLine(title, date5, status) {
   const raw = flat(title) ?? "(no subject)";
-  const shown = raw.startsWith("-- ") || raw.startsWith("\\") ? `\\${raw}` : raw;
+  const shown3 = raw.startsWith("-- ") || raw.startsWith("\\") ? `\\${raw}` : raw;
   const sep2 = ` \u2014 ${date5} \u2014 `;
   const room = BRIEF_MAX - sep2.length;
-  if (shown.length + status.length <= room) return `${shown}${sep2}${status}`;
-  const titleRoom = Math.max(room - status.length, Math.min(shown.length, TITLE_FLOOR));
-  const t = cut(shown, titleRoom);
+  if (shown3.length + status.length <= room) return `${shown3}${sep2}${status}`;
+  const titleRoom = Math.max(room - status.length, Math.min(shown3.length, TITLE_FLOOR));
+  const t = cut(shown3, titleRoom);
   return cut(`${t}${sep2}${cut(status, room - t.length)}`, BRIEF_MAX);
 }
 var BRIEF_MORE = "-- more";
@@ -69921,7 +69921,7 @@ function registerWriteTools(server, client2) {
   server.registerTool(
     "outlook_create_draft",
     {
-      description: "Create a draft message in the Drafts folder without sending it. Returns the created draft, which can be reviewed and sent from Outlook. It does not ask to confirm: a draft reaches nobody until it is sent from Outlook. Calling it twice leaves two drafts. " + TIMEOUT_SENTENCE,
+      description: "Create a draft message in the Drafts folder without sending it. Returns the created draft, which can be changed with outlook_update_draft and sent with outlook_send_draft. It does not ask to confirm: a draft reaches nobody until it is sent. Calling it twice leaves two drafts. " + TIMEOUT_SENTENCE,
       // Self-only and additive, like outlook_reply with draftOnly: nothing is
       // overwritten or sent. Not idempotent: a repeat creates a second draft.
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
@@ -70054,8 +70054,8 @@ function registerWriteTools(server, client2) {
           }
           const echoed = await client2.write("PATCH", pathOf(id), payload);
           const after = echoed && typeof echoed === "object" ? echoed : await client2.get(`${pathOf(id)}?$select=IsRead,Flag,Categories`) ?? {};
-          const unchanged = unchangedFields(payload, after);
-          return unchanged.length ? { id, ok: false, error: `Outlook accepted the write but these did not change: ${unchanged.join(", ")}.` } : { id, ok: true };
+          const unchanged2 = unchangedFields(payload, after);
+          return unchanged2.length ? { id, ok: false, error: `Outlook accepted the write but these did not change: ${unchanged2.join(", ")}.` } : { id, ok: true };
         } catch (e) {
           if (isCredentialFailure(e)) throw e;
           return { id, ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -70258,28 +70258,28 @@ function registerWriteTools(server, client2) {
       await client2.write("PATCH", path2, payload);
       const writtenZone = (payload.Start ?? payload.End)?.TimeZone ?? tz;
       const after = await readEvent(writtenZone);
-      const unchanged = [];
-      if (payload.Subject !== void 0 && after?.Subject !== payload.Subject) unchanged.push("Subject");
+      const unchanged2 = [];
+      if (payload.Subject !== void 0 && after?.Subject !== payload.Subject) unchanged2.push("Subject");
       for (const key of ["Start", "End"]) {
         const want = payload[key];
-        if (want && trimTime2(after?.[key]?.DateTime) !== trimTime2(want.DateTime)) unchanged.push(key);
+        if (want && trimTime2(after?.[key]?.DateTime) !== trimTime2(want.DateTime)) unchanged2.push(key);
       }
       if (payload.Location !== void 0 && after?.Location?.DisplayName !== args.location) {
-        unchanged.push("Location");
+        unchanged2.push("Location");
       }
       if (payload.Attendees !== void 0) {
         const want = payload.Attendees.map(lower).sort().join();
         const got = (after?.Attendees ?? []).map(lower).sort().join();
-        if (want !== got) unchanged.push("Attendees");
+        if (want !== got) unchanged2.push("Attendees");
       }
       const joinUrl = joinUrlOf(after);
-      if (addTeams && !joinUrl) unchanged.push("Teams meeting");
+      if (addTeams && !joinUrl) unchanged2.push("Teams meeting");
       return minifiedResult({
-        updated: unchanged.length === 0,
+        updated: unchanged2.length === 0,
         Id: after?.Id ?? args.id,
         changed: Object.keys(payload),
         ...joinUrl ? { JoinUrl: joinUrl } : {},
-        ...unchanged.length ? { warning: `Outlook accepted the update but these did not change: ${unchanged.join(", ")}.` } : {}
+        ...unchanged2.length ? { warning: `Outlook accepted the update but these did not change: ${unchanged2.join(", ")}.` } : {}
       });
     }
   );
@@ -71826,6 +71826,424 @@ function registerRuleTools(server, client2) {
   );
 }
 
+// src/tools/folders.ts
+init_zod();
+init_dist2();
+var ROOT = "msgfolderroot";
+var RULES_PATH2 = "/me/MailFolders/inbox/MessageRules";
+var folderPath = (id) => `/me/mailfolders/${encodeURIComponent(id)}`;
+var PROTECTED = /* @__PURE__ */ new Set([...WELL_KNOWN, ROOT]);
+var LIST_HINT = 'Pass a folder id from outlook_list_folders or a well-known name such as "inbox".';
+function refuseWellKnown(id, verb) {
+  if (PROTECTED.has(id.toLowerCase())) {
+    throw new McpToolError(`"${id}" is one of Outlook's own folders and cannot be ${verb}.`, {
+      hint: "Pick a folder you created; list them with outlook_list_folders."
+    });
+  }
+}
+async function readFolder(client2, id) {
+  try {
+    return await client2.get(folderPath(id));
+  } catch (e) {
+    const status = errorStatusOf(e);
+    if (status !== 400 && status !== 404) throw e;
+    throw new McpToolError(`No mail folder matches "${id}".`, { hint: LIST_HINT });
+  }
+}
+var shown = (f) => ({ ...compactFolder(f), Parent: f.ParentFolderId });
+var STILL_DELETING = "Outlook did not answer in time. A large folder keeps running its delete on the server for minutes after the request (about 75 messages a second), so it is probably still deleting. Check the folder's Total in outlook_list_folders: falling means it is working, gone means done. Do not resend the delete.";
+var plural2 = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+var SUBTREE_CAP = 500;
+var CHILD_SELECT = "Id,TotalItemCount,UnreadItemCount,ChildFolderCount";
+async function subtree(client2, root) {
+  const out = {
+    total: root.TotalItemCount ?? 0,
+    unread: root.UnreadItemCount ?? 0,
+    subfolders: 0,
+    ids: [root.Id],
+    partial: false
+  };
+  const queue = (root.ChildFolderCount ?? 0) > 0 ? [{ id: root.Id, expected: root.ChildFolderCount ?? 0 }] : [];
+  while (queue.length) {
+    const { id: parent, expected } = queue.shift();
+    if (out.subfolders >= SUBTREE_CAP) {
+      out.partial = true;
+      break;
+    }
+    let page;
+    try {
+      page = await client2.get(`${folderPath(parent)}/childfolders`, { query: { $select: CHILD_SELECT, $top: 100 } });
+    } catch {
+      out.partial = true;
+      continue;
+    }
+    const kids = page.value ?? [];
+    if (kids.length >= 100 || kids.length < expected) out.partial = true;
+    for (const k of kids) {
+      out.subfolders++;
+      out.total += k.TotalItemCount ?? 0;
+      out.unread += k.UnreadItemCount ?? 0;
+      if (k.Id) {
+        out.ids.push(k.Id);
+        if ((k.ChildFolderCount ?? 0) > 0) queue.push({ id: k.Id, expected: k.ChildFolderCount ?? 0 });
+      }
+    }
+  }
+  return out;
+}
+function contents(t) {
+  const atLeast = t.partial ? "at least " : "";
+  const mail = `${atLeast}${plural2(t.total, "message")}${t.unread ? ` (${t.unread} unread)` : ""}`;
+  return t.subfolders ? `${mail}, counting its ${atLeast}${plural2(t.subfolders, "subfolder")}` : mail;
+}
+async function rulesUsing(client2, ids) {
+  const doomed = new Set(ids);
+  try {
+    const page = await client2.get(RULES_PATH2);
+    return (page.value ?? []).filter((r) => doomed.has(r.Actions?.MoveToFolder ?? "") || doomed.has(r.Actions?.CopyToFolder ?? "")).map((r) => r.DisplayName ?? "(unnamed rule)");
+  } catch {
+    return [];
+  }
+}
+function registerFolderTools(server, client2) {
+  server.registerTool(
+    "outlook_create_folder",
+    {
+      description: "Create a mail folder: at the top level of the mailbox by default, or inside `parent`. Nothing reaches anyone else and an empty folder is easily deleted, so this does not ask for confirmation. Point rules or moves at the returned Id. " + TIMEOUT_SENTENCE,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+      _meta: workMeta("change", { aliases: ["new folder", "add folder", "make folder"] }),
+      inputSchema: external_exports.object({
+        name: external_exports.string().min(1).describe("Folder name"),
+        parent: external_exports.string().min(1).optional().describe('Folder id or well-known name (e.g. "inbox") to create it inside. Omit for the top level.')
+      })
+    },
+    async ({ name: name3, parent }) => {
+      const path2 = `${folderPath(parent ?? ROOT)}/childfolders`;
+      let write;
+      try {
+        write = await writeOrUnknown2(() => client2.write("POST", path2, { DisplayName: name3 }), "outlook_list_folders");
+      } catch (e) {
+        const status = errorStatusOf(e);
+        if (status === 409) {
+          throw new McpToolError(`A folder named "${name3}" already exists there.`, {
+            hint: "Use the existing one (see outlook_list_folders) or pick another name."
+          });
+        }
+        if (parent !== void 0 && (status === 400 || status === 404)) {
+          throw new McpToolError(`No mail folder matches "${parent}".`, { hint: LIST_HINT });
+        }
+        throw e;
+      }
+      if (!write.ok) return write.result;
+      return minifiedResult({ created: true, ...shown(write.value ?? { DisplayName: name3 }) });
+    }
+  );
+  server.registerTool(
+    "outlook_update_folder",
+    {
+      description: "Rename a mail folder, move it under another folder, or both. Its mail and subfolders go with it, and rules that file into it keep working. Outlook's own folders (Inbox, Archive, \u2026) are refused. The result is verified by re-reading the folder. " + TIMEOUT_SENTENCE + " " + CONFIRM_FLOW_SENTENCE,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      _meta: workMeta("change", { aliases: ["rename folder", "move folder"] }),
+      inputSchema: external_exports.object({
+        id: external_exports.string().min(1).describe("Folder Id from outlook_list_folders"),
+        name: external_exports.string().min(1).optional().describe("New name"),
+        parent: external_exports.string().min(1).optional().describe('Folder id or well-known name to move it into; "msgfolderroot" is the top level'),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ id, name: name3, parent, confirmToken }, ctx) => {
+      if (name3 === void 0 && parent === void 0) {
+        throw new McpToolError("Nothing to change on this folder.", { hint: "Pass `name`, `parent` or both." });
+      }
+      refuseWellKnown(id, "renamed or moved");
+      if (parent !== void 0 && parent === id) {
+        throw new McpToolError("A folder cannot be moved into itself.", { hint: "Pick a different `parent`." });
+      }
+      const current = await readFolder(client2, id);
+      const destination = parent === void 0 ? void 0 : await folderId(client2, parent);
+      const label = current.DisplayName ?? id;
+      const changes = [
+        ...name3 !== void 0 ? [`rename it to "${name3}"`] : [],
+        ...parent !== void 0 ? [parent.toLowerCase() === ROOT ? "move it to the top level" : `move it into ${parent}`] : []
+      ].join(" and ");
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_update_folder",
+        action: "mail.folder_update",
+        message: `Review and confirm: ${changes}.`,
+        summary: `Folder "${label}": ${changes}.`,
+        account: void 0,
+        target: id,
+        // A rename and a move are separate calls; preview both, as sent.
+        payload: [
+          ...name3 !== void 0 ? [{ method: "PATCH", path: folderPath(id), body: { DisplayName: name3 } }] : [],
+          ...destination !== void 0 ? [{ method: "POST", path: `${folderPath(id)}/move`, body: { DestinationId: destination } }] : []
+        ],
+        confirmToken,
+        preview: { current: shown(current) }
+      });
+      if (gate) return gate;
+      if (name3 !== void 0) {
+        const rename3 = await writeOrUnknown2(() => client2.write("PATCH", folderPath(id), { DisplayName: name3 }), "outlook_list_folders");
+        if (!rename3.ok) return rename3.result;
+      }
+      let finalId = id;
+      if (destination !== void 0) {
+        const move = await writeOrUnknown2(
+          () => client2.write("POST", `${folderPath(id)}/move`, { DestinationId: destination }),
+          "outlook_list_folders"
+        );
+        if (!move.ok) return move.result;
+        finalId = move.value?.Id ?? id;
+      }
+      const read = await readBack(() => client2.get(folderPath(finalId)));
+      if (!read.ok) return minifiedResult({ updated: true, Id: finalId, ...unverified("outlook_list_folders") });
+      const after = read.value;
+      const stale = [
+        ...name3 !== void 0 && after.DisplayName !== name3 ? ["name"] : [],
+        ...destination !== void 0 && after.ParentFolderId !== destination ? ["location"] : []
+      ];
+      return minifiedResult({
+        updated: stale.length === 0,
+        ...shown(after),
+        ...stale.length ? { warning: `Outlook accepted the write but the ${stale.join(" and ")} did not change.` } : {}
+      });
+    }
+  );
+  server.registerTool(
+    "outlook_delete_folder",
+    {
+      description: `Delete a mail folder together with every message and subfolder in it. This is permanent: the folder does NOT go to Deleted Items, so it cannot be restored from there. To keep the mail, move it out first (outlook_move_message). The confirmation totals the mail in the folder and every subfolder beneath it, and names any inbox rules that file into them (those rules stop working). Outlook's own folders are refused. The result is verified by re-reading the folder. A folder holding thousands of messages takes minutes to delete, so the call can come back with status "unknown" while Outlook keeps deleting: check its Total in outlook_list_folders falling, and never resend. ` + CONFIRM_FLOW_SENTENCE,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      _meta: workMeta("change", { aliases: ["remove folder"] }),
+      inputSchema: external_exports.object({
+        id: external_exports.string().min(1).describe("Folder Id from outlook_list_folders"),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ id, confirmToken }, ctx) => {
+      refuseWellKnown(id, "deleted");
+      const current = await readFolder(client2, id);
+      const label = current.DisplayName ?? id;
+      const tree = await subtree(client2, { ...current, Id: current.Id ?? id });
+      const rules = await rulesUsing(client2, tree.ids);
+      const ruleNote = rules.length ? ` These inbox rules file mail into it or its subfolders and will stop working: ${rules.map((r) => `"${r}"`).join(", ")}.` : "";
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_delete_folder",
+        action: "mail.folder_delete",
+        message: `Review and confirm permanently deleting this folder with its ${contents(tree)} (it does not go to Deleted Items):${ruleNote}`,
+        summary: `Permanently delete folder "${label}" with its ${contents(tree)}; it does not go to Deleted Items.${ruleNote}`,
+        account: void 0,
+        target: id,
+        request: { method: "DELETE", path: folderPath(id) },
+        confirmToken,
+        preview: { current: shown(current), ...rules.length ? { rulesUsingIt: rules } : {} }
+      });
+      if (gate) return gate;
+      let write;
+      try {
+        write = await writeOrUnknown2(() => client2.write("DELETE", folderPath(id)), "outlook_list_folders");
+      } catch (e) {
+        if (errorStatusOf(e) === 400 && /ErrorDeleteDistinguishedFolder/.test(String(e.message))) {
+          throw new McpToolError(`"${label}" is one of Outlook's own folders and cannot be deleted.`, {
+            hint: "Nothing was deleted. Leave it in place, or delete the folders you created inside it instead."
+          });
+        }
+        throw e;
+      }
+      if (!write.ok) return minifiedResult({ status: "unknown", Id: id, warning: STILL_DELETING });
+      const read = await readBack(() => client2.get(folderPath(id)));
+      if (!read.ok && errorStatusOf(read.error) === 404) return minifiedResult({ deleted: true, Id: id });
+      if (!read.ok) return minifiedResult({ deleted: true, Id: id, ...unverified("outlook_list_folders") });
+      return minifiedResult({ deleted: false, Id: id, warning: "Outlook accepted the delete but the folder is still there." });
+    }
+  );
+}
+
+// src/tools/drafts.ts
+init_zod();
+init_dist2();
+var DRAFT_SELECT = "Id,IsDraft,Subject,Body,ToRecipients,CcRecipients,BccRecipients,WebLink";
+var messagePath = (id) => `/me/messages/${encodeURIComponent(id)}`;
+var PREVIEW_BODY_MAX = 2e3;
+var addresses2 = (list) => (list ?? []).map((r) => r.EmailAddress?.Address ?? "");
+var sameAddresses = (a, b) => addresses2(a).map((x) => x.toLowerCase()).sort().join("\n") === addresses2(b).map((x) => x.toLowerCase()).sort().join("\n");
+var sameText = (a, b) => (a ?? "").replace(/\r\n/g, "\n").trim() === (b ?? "").replace(/\r\n/g, "\n").trim();
+function shown2(d) {
+  return {
+    Id: d.Id,
+    Subject: d.Subject,
+    To: addresses2(d.ToRecipients),
+    Cc: addresses2(d.CcRecipients),
+    Bcc: addresses2(d.BccRecipients),
+    WebLink: d.WebLink
+  };
+}
+function currentBody(d) {
+  const content = d.Body?.Content ?? "";
+  return content.length > PREVIEW_BODY_MAX ? `${content.slice(0, PREVIEW_BODY_MAX)}\u2026 (${content.length} characters in all)` : content;
+}
+function unchanged(payload, after) {
+  const out = [];
+  if (payload.Subject !== void 0 && after.Subject !== payload.Subject) out.push("Subject");
+  if (payload.Body) {
+    const ok = payload.Body.ContentType === "HTML" ? after.Body?.ContentType === "HTML" : after.Body?.ContentType === "Text" && sameText(after.Body?.Content, payload.Body.Content);
+    if (!ok) out.push("Body");
+  }
+  if (payload.ToRecipients && !sameAddresses(after.ToRecipients, payload.ToRecipients)) out.push("To");
+  if (payload.CcRecipients && !sameAddresses(after.CcRecipients, payload.CcRecipients)) out.push("Cc");
+  if (payload.BccRecipients && !sameAddresses(after.BccRecipients, payload.BccRecipients)) out.push("Bcc");
+  return out;
+}
+async function readDraft(client2, id) {
+  let found;
+  try {
+    found = await client2.get(`${messagePath(id)}?$select=${DRAFT_SELECT}`);
+  } catch (e) {
+    const status = errorStatusOf(e);
+    if (status !== 400 && status !== 404) throw e;
+    throw new McpToolError(`No message matches "${id}".`, {
+      hint: 'Pass a draft Id from outlook_create_draft, outlook_reply with draftOnly, or outlook_list_messages with folder "drafts".'
+    });
+  }
+  if (found.IsDraft !== true) {
+    throw new McpToolError(`"${found.Subject ?? id}" is not a draft, so it cannot be edited.`, {
+      hint: "Only unsent drafts can be changed. To send something different, create a new draft or use outlook_send_message."
+    });
+  }
+  return found;
+}
+var SEND_CHECK_TRIES = 8;
+function registerDraftTools(server, client2, opts = {}) {
+  const delayMs = opts.sendCheckDelayMs ?? 1500;
+  server.registerTool(
+    "outlook_update_draft",
+    {
+      description: "Edit an unsent draft: its subject, body, and To, Cc or Bcc recipients. Only what you pass changes, and each field you pass replaces the current one: `body` replaces the WHOLE body (in a reply or forward draft that includes the quoted original), and `to: []` clears the To line. Nothing is sent; send it with outlook_send_draft. Messages that are not drafts are refused. The confirmation shows the draft as it is now, because the replaced text cannot be recovered. The result is checked against the draft Outlook returns. " + TIMEOUT_SENTENCE + " " + CONFIRM_FLOW_SENTENCE,
+      // Overwrites text that is not kept anywhere else, so it is destructive
+      // even though it reaches nobody. Repeating the same edit changes nothing.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      _meta: workMeta("change", { aliases: ["edit draft", "change draft", "rewrite draft"] }),
+      inputSchema: external_exports.object({
+        id: external_exports.string().min(1).describe('Draft Id (from outlook_create_draft, outlook_reply draftOnly, or outlook_list_messages folder "drafts")'),
+        subject: external_exports.string().optional().describe("New subject line"),
+        body: external_exports.string().optional().describe("New body; replaces the whole current body"),
+        html: external_exports.boolean().optional().describe("Treat `body` as HTML (default: plain text). Only with `body`."),
+        to: recipientList.describe("New To recipients; replaces the list ([] clears it)"),
+        cc: recipientList.describe("New Cc recipients; replaces the list ([] clears it)"),
+        bcc: recipientList.describe("New Bcc recipients; replaces the list ([] clears it)"),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ id, subject, body, html, to, cc, bcc, confirmToken }, ctx) => {
+      if (html !== void 0 && body === void 0) {
+        throw new McpToolError("`html` only applies together with `body`.", { hint: "Pass the new `body` as well." });
+      }
+      const payload = {
+        ...subject !== void 0 ? { Subject: subject } : {},
+        ...body !== void 0 ? { Body: { ContentType: html === true ? "HTML" : "Text", Content: body } } : {},
+        ...to !== void 0 ? { ToRecipients: toRecipients(to) } : {},
+        ...cc !== void 0 ? { CcRecipients: toRecipients(cc) } : {},
+        ...bcc !== void 0 ? { BccRecipients: toRecipients(bcc) } : {}
+      };
+      if (Object.keys(payload).length === 0) {
+        throw new McpToolError("Nothing to change on this draft.", {
+          hint: "Pass at least one of subject, body, to, cc or bcc."
+        });
+      }
+      const current = await readDraft(client2, id);
+      const fields = [
+        ...subject !== void 0 ? ["subject"] : [],
+        ...body !== void 0 ? ["whole body"] : [],
+        ...to !== void 0 ? ["To list"] : [],
+        ...cc !== void 0 ? ["Cc list"] : [],
+        ...bcc !== void 0 ? ["Bcc list"] : []
+      ];
+      const path2 = messagePath(id);
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_update_draft",
+        action: "mail.draft_update",
+        message: `Review and confirm this draft edit. It will replace the draft's ${fields.join(", ")}; the current draft is shown below. Nothing is sent.`,
+        summary: `Edit draft "${current.Subject ?? id}": replace its ${fields.join(", ")}. Nothing is sent.`,
+        account: void 0,
+        target: id,
+        request: { method: "PATCH", path: path2, body: payload },
+        confirmToken,
+        preview: { current: { ...shown2(current), Body: currentBody(current) } }
+      });
+      if (gate) return gate;
+      const write = await writeOrUnknown2(() => client2.write("PATCH", path2, payload), "Drafts");
+      if (!write.ok) return write.result;
+      const echoed = write.value;
+      let after;
+      if (echoed && typeof echoed === "object" && echoed.Id) {
+        after = echoed;
+      } else {
+        const read = await readBack(() => client2.get(`${path2}?$select=${DRAFT_SELECT}`));
+        if (!read.ok) return minifiedResult({ updated: true, Id: id, ...unverified("the draft in Drafts") });
+        after = read.value;
+      }
+      const stale = unchanged(payload, after);
+      return minifiedResult({
+        updated: stale.length === 0,
+        ...shown2(after),
+        ...stale.length ? { warning: `Outlook accepted the edit but these did not change: ${stale.join(", ")}.` } : {}
+      });
+    }
+  );
+  server.registerTool(
+    "outlook_send_draft",
+    {
+      description: "Send an existing draft as it stands: its subject, body, recipients and attachments go out unchanged. To change it first, use outlook_update_draft. Refuses a message that is not a draft, or a draft with no recipients. The confirmation shows exactly what will be sent and to whom. Once sent, Outlook files the copy in Sent Items under a new id. Outlook finishes a send in the background, so the result waits a few seconds for the draft to leave Drafts; if it has not, the result says to check Sent Items, never to resend. " + TIMEOUT_SENTENCE + " " + CONFIRM_FLOW_SENTENCE + " " + CONFIRM_INJECTION_RULE,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+      _meta: workMeta("send", { aliases: ["send draft", "send the draft"] }),
+      inputSchema: external_exports.object({
+        id: external_exports.string().min(1).describe('Draft Id (from outlook_create_draft, outlook_reply draftOnly, or outlook_list_messages folder "drafts")'),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ id, confirmToken }, ctx) => {
+      const current = await readDraft(client2, id);
+      const view = shown2(current);
+      const recipients = [...view.To, ...view.Cc, ...view.Bcc];
+      if (recipients.length === 0) {
+        throw new McpToolError(`Draft "${current.Subject ?? id}" has no recipients, so there is no one to send it to.`, {
+          hint: "Add To, Cc or Bcc recipients with outlook_update_draft, then send it."
+        });
+      }
+      const path2 = `${messagePath(id)}/send`;
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_send_draft",
+        action: "mail.send_draft",
+        message: "Review and confirm this email before it is sent:",
+        summary: `Send draft "${current.Subject ?? ""}" to ${recipients.join(", ")}`,
+        account: void 0,
+        target: id,
+        request: { method: "POST", path: path2 },
+        // The send carries no body: what goes out is the stored draft, so that is what is shown and bound.
+        willSend: { Subject: current.Subject, To: view.To, Cc: view.Cc, Bcc: view.Bcc, Body: currentBody(current) },
+        confirmToken
+      });
+      if (gate) return gate;
+      const write = await writeOrUnknown2(() => client2.write("POST", path2), "Sent Items");
+      if (!write.ok) return write.result;
+      const summary = { subject: current.Subject, recipients };
+      for (let attempt = 1; attempt <= SEND_CHECK_TRIES; attempt++) {
+        const read = await readBack(() => client2.get(`${messagePath(id)}?$select=Id,IsDraft`));
+        if (!read.ok && errorStatusOf(read.error) === 404) return minifiedResult({ sent: true, ...summary });
+        if (!read.ok) return minifiedResult({ sent: true, ...summary, ...unverified("Sent Items") });
+        if (read.value.IsDraft !== true) return minifiedResult({ sent: true, ...summary });
+        if (attempt < SEND_CHECK_TRIES) await new Promise((r) => setTimeout(r, delayMs));
+      }
+      return minifiedResult({
+        sent: true,
+        verified: false,
+        ...summary,
+        warning: `Outlook accepted the send, but the draft had not left Drafts after ${Math.round(delayMs * (SEND_CHECK_TRIES - 1) / 1e3)} s; Outlook is probably still delivering it. Check Sent Items before doing anything else, and do not send it again unless it is missing there.`
+      });
+    }
+  );
+}
+
 // src/tools/copilot.ts
 init_zod();
 init_dist2();
@@ -72349,6 +72767,8 @@ await runMcp({
     registerWriteTools,
     registerExportTools,
     registerRuleTools,
+    registerFolderTools,
+    registerDraftTools,
     (server) => registerCopilotTools(server, copilot, client),
     registerHealthcheckTool
   ]

package/dist/index.js

@@ -9,6 +9,8 @@ import { registerWriteTools } from './tools/writes.js';
 import { registerHealthcheckTool } from './tools/healthcheck.js';
 import { registerExportTools } from './tools/export.js';
 import { registerRuleTools } from './tools/rules.js';
+import { registerFolderTools } from './tools/folders.js';
+import { registerDraftTools } from './tools/drafts.js';
 import { registerCopilotTools } from './tools/copilot.js';
 import { CopilotClient } from './copilot/client.js';
 loadDotenvSafely();
@@ -45,6 +47,8 @@ await runMcp({
         registerWriteTools,
         registerExportTools,
         registerRuleTools,
+        registerFolderTools,
+        registerDraftTools,
         (server) => registerCopilotTools(server, copilot, client),
         registerHealthcheckTool,
     ],

package/dist/tools/drafts.js

@@ -0,0 +1,219 @@
+import { z } from 'zod';
+import { CONFIRM_FLOW_SENTENCE, CONFIRM_INJECTION_RULE, confirmTokenParam, confirmWrite, errorStatusOf, McpToolError, minifiedResult, } from '@chrischall/mcp-utils';
+import { workMeta } from './_hints.js';
+import { readBack, unverified } from './rules.js';
+import { recipientList, TIMEOUT_SENTENCE, toRecipients, writeOrUnknown } from './writes.js';
+const DRAFT_SELECT = 'Id,IsDraft,Subject,Body,ToRecipients,CcRecipients,BccRecipients,WebLink';
+const messagePath = (id) => `/me/messages/${encodeURIComponent(id)}`;
+/** The preview shows the body being replaced; past this it is cut, and says so. */
+const PREVIEW_BODY_MAX = 2000;
+const addresses = (list) => (list ?? []).map((r) => r.EmailAddress?.Address ?? '');
+const sameAddresses = (a, b) => addresses(a).map((x) => x.toLowerCase()).sort().join('\n') === addresses(b).map((x) => x.toLowerCase()).sort().join('\n');
+/** Outlook may store line breaks as CRLF; the words are what must match. */
+const sameText = (a, b) => (a ?? '').replace(/\r\n/g, '\n').trim() === (b ?? '').replace(/\r\n/g, '\n').trim();
+function shown(d) {
+    return {
+        Id: d.Id,
+        Subject: d.Subject,
+        To: addresses(d.ToRecipients),
+        Cc: addresses(d.CcRecipients),
+        Bcc: addresses(d.BccRecipients),
+        WebLink: d.WebLink,
+    };
+}
+function currentBody(d) {
+    const content = d.Body?.Content ?? '';
+    return content.length > PREVIEW_BODY_MAX ? `${content.slice(0, PREVIEW_BODY_MAX)}… (${content.length} characters in all)` : content;
+}
+/** Fields the PATCH set that the draft Outlook returned does not show. */
+function unchanged(payload, after) {
+    const out = [];
+    if (payload.Subject !== undefined && after.Subject !== payload.Subject)
+        out.push('Subject');
+    if (payload.Body) {
+        // Outlook wraps an HTML body in its own <html><head>…, so only its type can be checked.
+        const ok = payload.Body.ContentType === 'HTML'
+            ? after.Body?.ContentType === 'HTML'
+            : after.Body?.ContentType === 'Text' && sameText(after.Body?.Content, payload.Body.Content);
+        if (!ok)
+            out.push('Body');
+    }
+    if (payload.ToRecipients && !sameAddresses(after.ToRecipients, payload.ToRecipients))
+        out.push('To');
+    if (payload.CcRecipients && !sameAddresses(after.CcRecipients, payload.CcRecipients))
+        out.push('Cc');
+    if (payload.BccRecipients && !sameAddresses(after.BccRecipients, payload.BccRecipients))
+        out.push('Bcc');
+    return out;
+}
+async function readDraft(client, id) {
+    let found;
+    try {
+        found = await client.get(`${messagePath(id)}?$select=${DRAFT_SELECT}`);
+    }
+    catch (e) {
+        const status = errorStatusOf(e);
+        if (status !== 400 && status !== 404)
+            throw e;
+        throw new McpToolError(`No message matches "${id}".`, {
+            hint: 'Pass a draft Id from outlook_create_draft, outlook_reply with draftOnly, or outlook_list_messages with folder "drafts".',
+        });
+    }
+    if (found.IsDraft !== true) {
+        throw new McpToolError(`"${found.Subject ?? id}" is not a draft, so it cannot be edited.`, {
+            hint: 'Only unsent drafts can be changed. To send something different, create a new draft or use outlook_send_message.',
+        });
+    }
+    return found;
+}
+/**
+ * How long to watch for a sent draft to leave Drafts. Outlook answers the send
+ * with 202 and delivers in the background: live 2026-11-10 the draft was still
+ * readable as a draft straight after the 202 although the mail arrived.
+ */
+const SEND_CHECK_TRIES = 8;
+export function registerDraftTools(server, client, opts = {}) {
+    const delayMs = opts.sendCheckDelayMs ?? 1500;
+    server.registerTool('outlook_update_draft', {
+        description: 'Edit an unsent draft: its subject, body, and To, Cc or Bcc recipients. Only what you pass changes, and each field you pass replaces the current one: `body` replaces the WHOLE body (in a reply or forward draft that includes the quoted original), and `to: []` clears the To line. Nothing is sent; send it with outlook_send_draft. Messages that are not drafts are refused. The confirmation shows the draft as it is now, because the replaced text cannot be recovered. The result is checked against the draft Outlook returns. ' +
+            TIMEOUT_SENTENCE +
+            ' ' +
+            CONFIRM_FLOW_SENTENCE,
+        // Overwrites text that is not kept anywhere else, so it is destructive
+        // even though it reaches nobody. Repeating the same edit changes nothing.
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+        _meta: workMeta('change', { aliases: ['edit draft', 'change draft', 'rewrite draft'] }),
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Draft Id (from outlook_create_draft, outlook_reply draftOnly, or outlook_list_messages folder "drafts")'),
+            subject: z.string().optional().describe('New subject line'),
+            body: z.string().optional().describe('New body; replaces the whole current body'),
+            html: z.boolean().optional().describe('Treat `body` as HTML (default: plain text). Only with `body`.'),
+            to: recipientList.describe('New To recipients; replaces the list ([] clears it)'),
+            cc: recipientList.describe('New Cc recipients; replaces the list ([] clears it)'),
+            bcc: recipientList.describe('New Bcc recipients; replaces the list ([] clears it)'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ id, subject, body, html, to, cc, bcc, confirmToken }, ctx) => {
+        if (html !== undefined && body === undefined) {
+            throw new McpToolError('`html` only applies together with `body`.', { hint: 'Pass the new `body` as well.' });
+        }
+        const payload = {
+            ...(subject !== undefined ? { Subject: subject } : {}),
+            ...(body !== undefined ? { Body: { ContentType: html === true ? 'HTML' : 'Text', Content: body } } : {}),
+            ...(to !== undefined ? { ToRecipients: toRecipients(to) } : {}),
+            ...(cc !== undefined ? { CcRecipients: toRecipients(cc) } : {}),
+            ...(bcc !== undefined ? { BccRecipients: toRecipients(bcc) } : {}),
+        };
+        if (Object.keys(payload).length === 0) {
+            throw new McpToolError('Nothing to change on this draft.', {
+                hint: 'Pass at least one of subject, body, to, cc or bcc.',
+            });
+        }
+        const current = await readDraft(client, id);
+        const fields = [
+            ...(subject !== undefined ? ['subject'] : []),
+            ...(body !== undefined ? ['whole body'] : []),
+            ...(to !== undefined ? ['To list'] : []),
+            ...(cc !== undefined ? ['Cc list'] : []),
+            ...(bcc !== undefined ? ['Bcc list'] : []),
+        ];
+        const path = messagePath(id);
+        const gate = await confirmWrite(ctx, {
+            tool: 'outlook_update_draft',
+            action: 'mail.draft_update',
+            message: `Review and confirm this draft edit. It will replace the draft's ${fields.join(', ')}; the current draft is shown below. Nothing is sent.`,
+            summary: `Edit draft "${current.Subject ?? id}": replace its ${fields.join(', ')}. Nothing is sent.`,
+            account: undefined,
+            target: id,
+            request: { method: 'PATCH', path, body: payload },
+            confirmToken,
+            preview: { current: { ...shown(current), Body: currentBody(current) } },
+        });
+        if (gate)
+            return gate;
+        const write = await writeOrUnknown(() => client.write('PATCH', path, payload), 'Drafts');
+        if (!write.ok)
+            return write.result;
+        // Outlook answers the PATCH with the updated draft; re-read only when it did not.
+        const echoed = write.value;
+        let after;
+        if (echoed && typeof echoed === 'object' && echoed.Id) {
+            after = echoed;
+        }
+        else {
+            const read = await readBack(() => client.get(`${path}?$select=${DRAFT_SELECT}`));
+            if (!read.ok)
+                return minifiedResult({ updated: true, Id: id, ...unverified('the draft in Drafts') });
+            after = read.value;
+        }
+        const stale = unchanged(payload, after);
+        return minifiedResult({
+            updated: stale.length === 0,
+            ...shown(after),
+            ...(stale.length ? { warning: `Outlook accepted the edit but these did not change: ${stale.join(', ')}.` } : {}),
+        });
+    });
+    server.registerTool('outlook_send_draft', {
+        description: 'Send an existing draft as it stands: its subject, body, recipients and attachments go out unchanged. To change it first, use outlook_update_draft. Refuses a message that is not a draft, or a draft with no recipients. The confirmation shows exactly what will be sent and to whom. Once sent, Outlook files the copy in Sent Items under a new id. Outlook finishes a send in the background, so the result waits a few seconds for the draft to leave Drafts; if it has not, the result says to check Sent Items, never to resend. ' +
+            TIMEOUT_SENTENCE +
+            ' ' +
+            CONFIRM_FLOW_SENTENCE +
+            ' ' +
+            CONFIRM_INJECTION_RULE,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: workMeta('send', { aliases: ['send draft', 'send the draft'] }),
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Draft Id (from outlook_create_draft, outlook_reply draftOnly, or outlook_list_messages folder "drafts")'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ id, confirmToken }, ctx) => {
+        const current = await readDraft(client, id);
+        const view = shown(current);
+        const recipients = [...view.To, ...view.Cc, ...view.Bcc];
+        if (recipients.length === 0) {
+            throw new McpToolError(`Draft "${current.Subject ?? id}" has no recipients, so there is no one to send it to.`, {
+                hint: 'Add To, Cc or Bcc recipients with outlook_update_draft, then send it.',
+            });
+        }
+        const path = `${messagePath(id)}/send`;
+        const gate = await confirmWrite(ctx, {
+            tool: 'outlook_send_draft',
+            action: 'mail.send_draft',
+            message: 'Review and confirm this email before it is sent:',
+            summary: `Send draft "${current.Subject ?? ''}" to ${recipients.join(', ')}`,
+            account: undefined,
+            target: id,
+            request: { method: 'POST', path },
+            // The send carries no body: what goes out is the stored draft, so that is what is shown and bound.
+            willSend: { Subject: current.Subject, To: view.To, Cc: view.Cc, Bcc: view.Bcc, Body: currentBody(current) },
+            confirmToken,
+        });
+        if (gate)
+            return gate;
+        const write = await writeOrUnknown(() => client.write('POST', path), 'Sent Items');
+        if (!write.ok)
+            return write.result;
+        const summary = { subject: current.Subject, recipients };
+        // Sending moves the draft out of Drafts, so its old id stops resolving,
+        // but only once Outlook has finished: watch for that for a few seconds.
+        // Outlook accepted the send, so nothing here ever reports "not sent": a
+        // resend on that word would mail everyone twice.
+        for (let attempt = 1; attempt <= SEND_CHECK_TRIES; attempt++) {
+            const read = await readBack(() => client.get(`${messagePath(id)}?$select=Id,IsDraft`));
+            if (!read.ok && errorStatusOf(read.error) === 404)
+                return minifiedResult({ sent: true, ...summary });
+            if (!read.ok)
+                return minifiedResult({ sent: true, ...summary, ...unverified('Sent Items') });
+            if (read.value.IsDraft !== true)
+                return minifiedResult({ sent: true, ...summary });
+            if (attempt < SEND_CHECK_TRIES)
+                await new Promise((r) => setTimeout(r, delayMs));
+        }
+        return minifiedResult({
+            sent: true,
+            verified: false,
+            ...summary,
+            warning: `Outlook accepted the send, but the draft had not left Drafts after ${Math.round((delayMs * (SEND_CHECK_TRIES - 1)) / 1000)} s; Outlook is probably still delivering it. Check Sent Items before doing anything else, and do not send it again unless it is missing there.`,
+        });
+    });
+}

package/dist/tools/folders.js

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+import { CONFIRM_FLOW_SENTENCE, confirmTokenParam, confirmWrite, errorStatusOf, McpToolError, minifiedResult, } from '@chrischall/mcp-utils';
+import { compactFolder } from '../view.js';
+import { workMeta } from './_hints.js';
+import { WELL_KNOWN } from './mail.js';
+import { folderId, readBack, unverified } from './rules.js';
+import { TIMEOUT_SENTENCE, writeOrUnknown } from './writes.js';
+/** The mailbox's top level: the parent of Inbox, Archive and the folders beside them. */
+const ROOT = 'msgfolderroot';
+const RULES_PATH = '/me/MailFolders/inbox/MessageRules';
+const folderPath = (id) => `/me/mailfolders/${encodeURIComponent(id)}`;
+const PROTECTED = new Set([...WELL_KNOWN, ROOT]);
+const LIST_HINT = 'Pass a folder id from outlook_list_folders or a well-known name such as "inbox".';
+/** Outlook's own folders cannot be renamed, moved or deleted, so refuse them by name before any request. */
+function refuseWellKnown(id, verb) {
+    if (PROTECTED.has(id.toLowerCase())) {
+        throw new McpToolError(`"${id}" is one of Outlook's own folders and cannot be ${verb}.`, {
+            hint: 'Pick a folder you created; list them with outlook_list_folders.',
+        });
+    }
+}
+async function readFolder(client, id) {
+    try {
+        return await client.get(folderPath(id));
+    }
+    catch (e) {
+        const status = errorStatusOf(e);
+        if (status !== 400 && status !== 404)
+            throw e;
+        throw new McpToolError(`No mail folder matches "${id}".`, { hint: LIST_HINT });
+    }
+}
+const shown = (f) => ({ ...compactFolder(f), Parent: f.ParentFolderId });
+/**
+ * Outlook deletes a big folder's mail after the DELETE is accepted, at about 75
+ * messages a second (live 2026-11-10: 13,370 took ~3 minutes, 63,466 ~14), so
+ * the call outlives the client timeout. A resend while it runs would only
+ * restart a delete that is already happening.
+ */
+const STILL_DELETING = 'Outlook did not answer in time. A large folder keeps running its delete on the server for minutes after the request (about 75 messages a second), so it is probably still deleting. Check the folder\'s Total in outlook_list_folders: falling means it is working, gone means done. Do not resend the delete.';
+const plural = (n, one) => `${n} ${one}${n === 1 ? '' : 's'}`;
+/** Past this many folders the walk stops and the counts read "at least". */
+const SUBTREE_CAP = 500;
+const CHILD_SELECT = 'Id,TotalItemCount,UnreadItemCount,ChildFolderCount';
+/**
+ * A folder's own TotalItemCount leaves out its subfolders, and a delete takes
+ * them all: live 2026-11-10 a parent read "0 messages" over 2,725. So the
+ * confirmation walks the tree. A failed or capped walk is reported as a lower
+ * bound rather than blocking the delete.
+ */
+async function subtree(client, root) {
+    const out = {
+        total: root.TotalItemCount ?? 0,
+        unread: root.UnreadItemCount ?? 0,
+        subfolders: 0,
+        ids: [root.Id],
+        partial: false,
+    };
+    const queue = (root.ChildFolderCount ?? 0) > 0 ? [{ id: root.Id, expected: root.ChildFolderCount ?? 0 }] : [];
+    while (queue.length) {
+        const { id: parent, expected } = queue.shift();
+        if (out.subfolders >= SUBTREE_CAP) {
+            out.partial = true;
+            break;
+        }
+        let page;
+        try {
+            page = await client.get(`${folderPath(parent)}/childfolders`, { query: { $select: CHILD_SELECT, $top: 100 } });
+        }
+        catch {
+            out.partial = true;
+            continue;
+        }
+        const kids = page.value ?? [];
+        // Hidden subfolders count in ChildFolderCount but are not listed (live: Conversation History).
+        if (kids.length >= 100 || kids.length < expected)
+            out.partial = true;
+        for (const k of kids) {
+            out.subfolders++;
+            out.total += k.TotalItemCount ?? 0;
+            out.unread += k.UnreadItemCount ?? 0;
+            if (k.Id) {
+                out.ids.push(k.Id);
+                if ((k.ChildFolderCount ?? 0) > 0)
+                    queue.push({ id: k.Id, expected: k.ChildFolderCount ?? 0 });
+            }
+        }
+    }
+    return out;
+}
+/** What goes with a folder when it is deleted, in words. */
+function contents(t) {
+    const atLeast = t.partial ? 'at least ' : '';
+    const mail = `${atLeast}${plural(t.total, 'message')}${t.unread ? ` (${t.unread} unread)` : ''}`;
+    return t.subfolders ? `${mail}, counting its ${atLeast}${plural(t.subfolders, 'subfolder')}` : mail;
+}
+/**
+ * Rules that file mail into this folder or any folder beneath it. Losing the folder breaks them, so the
+ * confirmation names them. A failed read only loses the warning, not the delete.
+ */
+async function rulesUsing(client, ids) {
+    const doomed = new Set(ids);
+    try {
+        const page = await client.get(RULES_PATH);
+        return (page.value ?? [])
+            .filter((r) => doomed.has(r.Actions?.MoveToFolder ?? '') || doomed.has(r.Actions?.CopyToFolder ?? ''))
+            .map((r) => r.DisplayName ?? '(unnamed rule)');
+    }
+    catch {
+        return [];
+    }
+}
+export function registerFolderTools(server, client) {
+    server.registerTool('outlook_create_folder', {
+        description: 'Create a mail folder: at the top level of the mailbox by default, or inside `parent`. Nothing reaches anyone else and an empty folder is easily deleted, so this does not ask for confirmation. Point rules or moves at the returned Id. ' +
+            TIMEOUT_SENTENCE,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+        _meta: workMeta('change', { aliases: ['new folder', 'add folder', 'make folder'] }),
+        inputSchema: z.object({
+            name: z.string().min(1).describe('Folder name'),
+            parent: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Folder id or well-known name (e.g. "inbox") to create it inside. Omit for the top level.'),
+        }),
+    }, async ({ name, parent }) => {
+        const path = `${folderPath(parent ?? ROOT)}/childfolders`;
+        let write;
+        try {
+            write = await writeOrUnknown(() => client.write('POST', path, { DisplayName: name }), 'outlook_list_folders');
+        }
+        catch (e) {
+            const status = errorStatusOf(e);
+            if (status === 409) {
+                throw new McpToolError(`A folder named "${name}" already exists there.`, {
+                    hint: 'Use the existing one (see outlook_list_folders) or pick another name.',
+                });
+            }
+            if (parent !== undefined && (status === 400 || status === 404)) {
+                throw new McpToolError(`No mail folder matches "${parent}".`, { hint: LIST_HINT });
+            }
+            throw e;
+        }
+        if (!write.ok)
+            return write.result;
+        return minifiedResult({ created: true, ...shown(write.value ?? { DisplayName: name }) });
+    });
+    server.registerTool('outlook_update_folder', {
+        description: 'Rename a mail folder, move it under another folder, or both. Its mail and subfolders go with it, and rules that file into it keep working. Outlook\'s own folders (Inbox, Archive, …) are refused. The result is verified by re-reading the folder. ' +
+            TIMEOUT_SENTENCE +
+            ' ' +
+            CONFIRM_FLOW_SENTENCE,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: workMeta('change', { aliases: ['rename folder', 'move folder'] }),
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Folder Id from outlook_list_folders'),
+            name: z.string().min(1).optional().describe('New name'),
+            parent: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Folder id or well-known name to move it into; "msgfolderroot" is the top level'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ id, name, parent, confirmToken }, ctx) => {
+        if (name === undefined && parent === undefined) {
+            throw new McpToolError('Nothing to change on this folder.', { hint: 'Pass `name`, `parent` or both.' });
+        }
+        refuseWellKnown(id, 'renamed or moved');
+        if (parent !== undefined && parent === id) {
+            throw new McpToolError('A folder cannot be moved into itself.', { hint: 'Pick a different `parent`.' });
+        }
+        const current = await readFolder(client, id);
+        const destination = parent === undefined ? undefined : await folderId(client, parent);
+        const label = current.DisplayName ?? id;
+        const changes = [
+            ...(name !== undefined ? [`rename it to "${name}"`] : []),
+            ...(parent !== undefined ? [parent.toLowerCase() === ROOT ? 'move it to the top level' : `move it into ${parent}`] : []),
+        ].join(' and ');
+        const gate = await confirmWrite(ctx, {
+            tool: 'outlook_update_folder',
+            action: 'mail.folder_update',
+            message: `Review and confirm: ${changes}.`,
+            summary: `Folder "${label}": ${changes}.`,
+            account: undefined,
+            target: id,
+            // A rename and a move are separate calls; preview both, as sent.
+            payload: [
+                ...(name !== undefined ? [{ method: 'PATCH', path: folderPath(id), body: { DisplayName: name } }] : []),
+                ...(destination !== undefined
+                    ? [{ method: 'POST', path: `${folderPath(id)}/move`, body: { DestinationId: destination } }]
+                    : []),
+            ],
+            confirmToken,
+            preview: { current: shown(current) },
+        });
+        if (gate)
+            return gate;
+        if (name !== undefined) {
+            const rename = await writeOrUnknown(() => client.write('PATCH', folderPath(id), { DisplayName: name }), 'outlook_list_folders');
+            if (!rename.ok)
+                return rename.result;
+        }
+        let finalId = id;
+        if (destination !== undefined) {
+            const move = await writeOrUnknown(() => client.write('POST', `${folderPath(id)}/move`, { DestinationId: destination }), 'outlook_list_folders');
+            if (!move.ok)
+                return move.result;
+            finalId = move.value?.Id ?? id;
+        }
+        const read = await readBack(() => client.get(folderPath(finalId)));
+        if (!read.ok)
+            return minifiedResult({ updated: true, Id: finalId, ...unverified('outlook_list_folders') });
+        const after = read.value;
+        const stale = [
+            ...(name !== undefined && after.DisplayName !== name ? ['name'] : []),
+            ...(destination !== undefined && after.ParentFolderId !== destination ? ['location'] : []),
+        ];
+        return minifiedResult({
+            updated: stale.length === 0,
+            ...shown(after),
+            ...(stale.length ? { warning: `Outlook accepted the write but the ${stale.join(' and ')} did not change.` } : {}),
+        });
+    });
+    server.registerTool('outlook_delete_folder', {
+        description: 'Delete a mail folder together with every message and subfolder in it. This is permanent: the folder does NOT go to Deleted Items, so it cannot be restored from there. To keep the mail, move it out first (outlook_move_message). The confirmation totals the mail in the folder and every subfolder beneath it, and names any inbox rules that file into them (those rules stop working). Outlook\'s own folders are refused. The result is verified by re-reading the folder. A folder holding thousands of messages takes minutes to delete, so the call can come back with status "unknown" while Outlook keeps deleting: check its Total in outlook_list_folders falling, and never resend. ' +
+            CONFIRM_FLOW_SENTENCE,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+        _meta: workMeta('change', { aliases: ['remove folder'] }),
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Folder Id from outlook_list_folders'),
+            confirmToken: confirmTokenParam,
+        }),
+    }, async ({ id, confirmToken }, ctx) => {
+        refuseWellKnown(id, 'deleted');
+        const current = await readFolder(client, id);
+        const label = current.DisplayName ?? id;
+        const tree = await subtree(client, { ...current, Id: current.Id ?? id });
+        const rules = await rulesUsing(client, tree.ids);
+        const ruleNote = rules.length
+            ? ` These inbox rules file mail into it or its subfolders and will stop working: ${rules.map((r) => `"${r}"`).join(', ')}.`
+            : '';
+        const gate = await confirmWrite(ctx, {
+            tool: 'outlook_delete_folder',
+            action: 'mail.folder_delete',
+            message: `Review and confirm permanently deleting this folder with its ${contents(tree)} (it does not go to Deleted Items):${ruleNote}`,
+            summary: `Permanently delete folder "${label}" with its ${contents(tree)}; it does not go to Deleted Items.${ruleNote}`,
+            account: undefined,
+            target: id,
+            request: { method: 'DELETE', path: folderPath(id) },
+            confirmToken,
+            preview: { current: shown(current), ...(rules.length ? { rulesUsingIt: rules } : {}) },
+        });
+        if (gate)
+            return gate;
+        let write;
+        try {
+            write = await writeOrUnknown(() => client.write('DELETE', folderPath(id)), 'outlook_list_folders');
+        }
+        catch (e) {
+            // Built-in folders such as RSS Feeds are not all reachable by a well-known name, so Outlook is the backstop.
+            if (errorStatusOf(e) === 400 && /ErrorDeleteDistinguishedFolder/.test(String(e.message))) {
+                throw new McpToolError(`"${label}" is one of Outlook's own folders and cannot be deleted.`, {
+                    hint: 'Nothing was deleted. Leave it in place, or delete the folders you created inside it instead.',
+                });
+            }
+            throw e;
+        }
+        if (!write.ok)
+            return minifiedResult({ status: 'unknown', Id: id, warning: STILL_DELETING });
+        const read = await readBack(() => client.get(folderPath(id)));
+        if (!read.ok && errorStatusOf(read.error) === 404)
+            return minifiedResult({ deleted: true, Id: id });
+        if (!read.ok)
+            return minifiedResult({ deleted: true, Id: id, ...unverified('outlook_list_folders') });
+        return minifiedResult({ deleted: false, Id: id, warning: 'Outlook accepted the delete but the folder is still there.' });
+    });
+}

package/dist/tools/mail.js

@@ -13,7 +13,7 @@ import { mailboxUntrusted, UNTRUSTED_DESCRIPTION_SUFFIX } from './_untrusted.js'
  * Well-known folder names the API accepts wherever a folder id is taken.
  * All eight verified present on a live mailbox 2026-09-20.
  */
-const WELL_KNOWN = [
+export const WELL_KNOWN = [
     'inbox',
     'drafts',
     'sentitems',

package/dist/tools/rules.js

@@ -56,7 +56,7 @@ function outlookConditions(c) {
  * first. That also refuses a folder that does not exist before anyone is asked
  * to confirm a rule that could never work.
  */
-async function folderId(client, folder) {
+export async function folderId(client, folder) {
     if (folder === undefined)
         return undefined;
     try {
@@ -114,7 +114,7 @@ function endsBeforeStart(start, end) {
  * The re-read after a write that Outlook accepted. If only the re-read fails,
  * the write still happened, so an error here would invite a duplicate.
  */
-async function readBack(read) {
+export async function readBack(read) {
     try {
         return { ok: true, value: await read() };
     }
@@ -122,7 +122,7 @@ async function readBack(read) {
         return { ok: false, error };
     }
 }
-const unverified = (where) => ({
+export const unverified = (where) => ({
     verified: false,
     warning: `Outlook accepted this change but it could not be re-read. Check ${where} before retrying.`,
 });

package/dist/tools/writes.js

@@ -6,11 +6,11 @@ import { mailboxTimeZone } from '../timezone.js';
 import { cappedRecipients, MAX_RECIPIENTS } from '../view.js';
 import { EVENT_EXPAND, isMeetingMessage, MEETING_MESSAGE_TYPE, resolvedEvent, } from './_invite.js';
 import { mailboxUntrusted, UNTRUSTED_DESCRIPTION_SUFFIX } from './_untrusted.js';
-const recipientList = z
+export const recipientList = z
     .array(z.string().min(3))
     .optional()
     .describe('Email addresses');
-function toRecipients(list) {
+export function toRecipients(list) {
     return (list ?? []).map((Address) => ({ EmailAddress: { Address } }));
 }
 /**
@@ -242,8 +242,8 @@ export function registerWriteTools(server, client) {
         return minifiedResult({ sent: true, subject, recipients: recipients || null });
     });
     server.registerTool('outlook_create_draft', {
-        description: 'Create a draft message in the Drafts folder without sending it. Returns the created draft, which can be reviewed and sent from Outlook. ' +
-            'It does not ask to confirm: a draft reaches nobody until it is sent from Outlook. Calling it twice leaves two drafts. ' +
+        description: 'Create a draft message in the Drafts folder without sending it. Returns the created draft, which can be changed with outlook_update_draft and sent with outlook_send_draft. ' +
+            'It does not ask to confirm: a draft reaches nobody until it is sent. Calling it twice leaves two drafts. ' +
             TIMEOUT_SENTENCE,
         // Self-only and additive, like outlook_reply with draftOnly: nothing is
         // overwritten or sent. Not idempotent: a repeat creates a second draft.

package/dist/version.js

@@ -10,4 +10,4 @@
  * line below and nowhere else — not even in prose.
  */
 export const PACKAGE_NAME = 'office-outlook-mcp';
-export const VERSION = '0.10.1'; // x-release-please-version
+export const VERSION = '0.11.0'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/office-outlook-mcp",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "mcpName": "io.github.chrischall/office-outlook-mcp",
   "description": "Outlook / Microsoft 365 MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/office-outlook-mcp",
     "source": "github"
   },
-  "version": "0.10.1",
+  "version": "0.11.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@chrischall/office-outlook-mcp",
-      "version": "0.10.1",
+      "version": "0.11.0",
       "transport": {
         "type": "stdio"
       },