@littlebearapps/outlook-assistant 3.11.2 → 3.12.1

package/email/draft.js

@@ -94,6 +94,51 @@ function formatDraftResponse(draft, actionLabel) {
   };
 }
 
+/**
+ * Raised when update/send/delete is pointed at something that is not an
+ * unsent draft. Carries the user-facing message; handleError turns it into
+ * a tool error without the generic "Error ..." prefix.
+ */
+class DraftGuardError extends Error {}
+
+/**
+ * Refuse to mutate anything that is not an unsent draft. Graph's PATCH,
+ * DELETE and /send accept any message id, so without this check a received
+ * or sent message could be edited, deleted or re-sent (#246).
+ * @param {string} accessToken - Graph access token
+ * @param {string} id - Message id the caller passed as the draft id
+ * @param {string} action - The draft action being guarded (for the message)
+ * @throws {DraftGuardError} If the id is not a draft or does not exist
+ */
+async function assertIsDraft(accessToken, id, action) {
+  let message;
+  try {
+    message = await callGraphAPI(
+      accessToken,
+      'GET',
+      `me/messages/${id}`,
+      null,
+      {
+        $select: 'id,isDraft,subject',
+      }
+    );
+  } catch (error) {
+    if (/status 404\b|ErrorItemNotFound/.test(error.message)) {
+      throw new DraftGuardError(
+        `Draft not found: \`${id}\`. It may already have been sent or deleted, or the ID is wrong.`
+      );
+    }
+    throw error;
+  }
+
+  if (message?.isDraft !== true) {
+    const subject = message?.subject ? ` ("${message.subject}")` : '';
+    throw new DraftGuardError(
+      `Message \`${id}\`${subject} is not a draft, so draft action=${action} refused it and nothing was changed. update/send/delete only act on unsent drafts.`
+    );
+  }
+}
+
 /**
  * Draft handler — routes to action-specific logic
  * @param {object} args - Tool arguments
@@ -242,12 +287,14 @@ async function handleUpdateDraft(args) {
     if (allowlistError) return allowlistError;
   }
 
-  // Rate limit check
-  const rateLimitError = checkRateLimit('draft');
-  if (rateLimitError) return rateLimitError;
-
   try {
     const accessToken = await ensureAuthenticated();
+    // Refusals must not consume a rate-limit slot, so check before counting
+    await assertIsDraft(accessToken, id, 'update');
+
+    const rateLimitError = checkRateLimit('draft');
+    if (rateLimitError) return rateLimitError;
+
     const draft = await callGraphAPI(
       accessToken,
       'PATCH',
@@ -272,12 +319,14 @@ async function handleSendDraft(args) {
     };
   }
 
-  // Rate limit via send-email counter (shares limit with direct sends)
-  const rateLimitError = checkRateLimit('send-email');
-  if (rateLimitError) return rateLimitError;
-
   try {
     const accessToken = await ensureAuthenticated();
+    await assertIsDraft(accessToken, id, 'send');
+
+    // Rate limit via send-email counter (shares limit with direct sends)
+    const rateLimitError = checkRateLimit('send-email');
+    if (rateLimitError) return rateLimitError;
+
     await callGraphAPI(accessToken, 'POST', `me/messages/${id}/send`);
     return {
       content: [
@@ -308,12 +357,13 @@ async function handleDeleteDraft(args) {
 
   try {
     const accessToken = await ensureAuthenticated();
+    await assertIsDraft(accessToken, id, 'delete');
     await callGraphAPI(accessToken, 'DELETE', `me/messages/${id}`);
     return {
       content: [
         {
           type: 'text',
-          text: `Draft \`${id}\` deleted.`,
+          text: `Draft \`${id}\` deleted. It skips Deleted Items and goes to Recoverable Items, where Outlook's "Recover deleted items" can restore it for a limited time, depending on your account.`,
         },
       ],
     };
@@ -458,6 +508,13 @@ async function handleForwardDraft(args) {
  * Standard error handler
  */
 function handleError(actionLabel, error) {
+  if (error instanceof DraftGuardError) {
+    return {
+      content: [{ type: 'text', text: error.message }],
+      isError: true,
+    };
+  }
+
   if (error.message === 'Authentication required') {
     return {
       content: [

package/email/export.js

@@ -4,6 +4,7 @@
  * Export emails to disk in MIME, Markdown, or JSON format.
  * Supports single and batch export with attachment handling.
  */
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -15,6 +16,11 @@ const {
   VERBOSITY,
 } = require('../utils/response-formatter');
 const { getEmailFields } = require('../utils/field-presets');
+const { resolveFolderPath } = require('./folder-utils');
+const { buildMailboxPrefix } = require('../utils/mailbox');
+const { quoteSearchPhrase } = require('../utils/odata-helpers');
+const { safeAttachmentFilename } = require('./attachments');
+const { writeClaimedFile } = require('../utils/safe-write');
 
 // Export format constants
 const EXPORT_FORMATS = {
@@ -42,6 +48,9 @@ async function handleExportEmail(args) {
   // hardcoded os.tmpdir(), inconsistent with target=messages.
   const savePath = args.outputDir || args.savePath;
   const includeAttachments = args.includeAttachments !== false;
+  // Message IDs are mailbox-scoped: route to /users/{mailbox} for a shared/
+  // delegated mailbox, else /me.
+  const prefix = buildMailboxPrefix(args.sharedMailbox || args.email || null);
 
   if (!emailId) {
     return {
@@ -62,7 +71,7 @@ async function handleExportEmail(args) {
     const email = await callGraphAPI(
       accessToken,
       'GET',
-      `me/messages/${emailId}`,
+      `${prefix}/messages/${emailId}`,
       null,
       { $select: selectFields }
     );
@@ -89,22 +98,15 @@ async function handleExportEmail(args) {
     // Paths claimed while writing this message (main file + attachments).
     const claimedPaths = new Set();
 
-    // Determine final save path
-    let finalPath;
-    if (
+    // Determine the save location. An explicit file path is the caller's to
+    // control — honour it exactly, including overwriting, since that is what
+    // an explicit path means. A directory (or the default temp dir) means we
+    // choose the name, so the write is exclusive (`wx`): it never clobbers an
+    // existing file and never follows a planted symlink.
+    const explicitFile =
       savePath &&
-      !(fs.existsSync(savePath) && fs.statSync(savePath).isDirectory())
-    ) {
-      // An explicit file path is the caller's to control — honour it exactly,
-      // including overwriting, since that is what an explicit path means.
-      finalPath = savePath;
-    } else {
-      // A directory (or the default temp dir) means we choose the name, so
-      // never clobber a file that is already there.
-      const dir = savePath || os.tmpdir();
-      fs.mkdirSync(dir, { recursive: true });
-      finalPath = claimUniquePath(dir, defaultBase, extension, claimedPaths);
-    }
+      !(fs.existsSync(savePath) && fs.statSync(savePath).isDirectory());
+    const targetDir = explicitFile ? null : savePath || os.tmpdir();
 
     // Export based on format
     let content;
@@ -112,7 +114,7 @@ async function handleExportEmail(args) {
 
     if (format === EXPORT_FORMATS.MIME || format === EXPORT_FORMATS.EML) {
       // MIME export - raw RFC822 format
-      content = await callGraphAPIRaw(accessToken, emailId);
+      content = await callGraphAPIRaw(accessToken, emailId, prefix);
     } else if (format === EXPORT_FORMATS.MARKDOWN) {
       // Markdown export using existing formatter
       content = formatEmailContent(email, VERBOSITY.FULL, {
@@ -147,11 +149,24 @@ async function handleExportEmail(args) {
       };
     }
 
-    // Auto-create the parent directory so callers don't have to pre-mkdir.
-    fs.mkdirSync(path.dirname(finalPath), { recursive: true });
-
-    // Save main file
-    fs.writeFileSync(finalPath, content, 'utf8');
+    // Save main file. Auto-create the directory so callers don't have to
+    // pre-mkdir.
+    let finalPath;
+    if (explicitFile) {
+      finalPath = savePath;
+      fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+      fs.writeFileSync(finalPath, content, 'utf8');
+    } else {
+      fs.mkdirSync(targetDir, { recursive: true });
+      finalPath = writeClaimedFile(
+        targetDir,
+        defaultBase,
+        extension,
+        claimedPaths,
+        content,
+        'utf8'
+      );
+    }
 
     // Handle attachments
     if (includeAttachments && email.hasAttachments) {
@@ -159,6 +174,7 @@ async function handleExportEmail(args) {
         accessToken,
         emailId,
         path.dirname(finalPath),
+        prefix,
         claimedPaths
       );
     }
@@ -241,6 +257,10 @@ async function handleBatchExportEmails(args) {
   const format = (args.format || EXPORT_FORMATS.MARKDOWN).toLowerCase();
   const outputDir = args.outputDir;
   const includeAttachments = args.includeAttachments === true; // Default false for batch
+  // Scope the whole batch (search + per-message fetch + attachments) to a
+  // shared/delegated mailbox when supplied.
+  const mailbox = args.sharedMailbox || args.email || null;
+  const prefix = buildMailboxPrefix(mailbox);
 
   if (!outputDir) {
     return {
@@ -266,7 +286,8 @@ async function handleBatchExportEmails(args) {
     if (Object.keys(searchQuery).length > 0 && emailIds.length === 0) {
       const searchResults = await searchEmailsForExport(
         accessToken,
-        searchQuery
+        searchQuery,
+        mailbox
       );
       idsToExport = searchResults.map((e) => e.id);
     }
@@ -300,7 +321,7 @@ async function handleBatchExportEmails(args) {
           const email = await callGraphAPI(
             accessToken,
             'GET',
-            `me/messages/${emailId}`,
+            `${prefix}/messages/${emailId}`,
             null,
             { $select: selectFields }
           );
@@ -312,8 +333,15 @@ async function handleBatchExportEmails(args) {
 
       const csvContent = formatEmailsAsCSV(emails);
       const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const csvPath = path.join(outputDir, `batch_export_${timestamp}.csv`);
-      fs.writeFileSync(csvPath, csvContent, 'utf8');
+      fs.mkdirSync(outputDir, { recursive: true });
+      const csvPath = writeClaimedFile(
+        outputDir,
+        `batch_export_${timestamp}`,
+        'csv',
+        null,
+        csvContent,
+        'utf8'
+      );
       const totalBytes = Buffer.byteLength(csvContent, 'utf8');
 
       let resultText = `## Batch Export Complete\n\n`;
@@ -356,7 +384,8 @@ async function handleBatchExportEmails(args) {
       format,
       outputDir,
       includeAttachments,
-      4 // Max concurrent
+      4, // Max concurrent
+      prefix
     );
 
     // Build response
@@ -446,8 +475,11 @@ async function handleBatchExportEmails(args) {
 
 /**
  * Search emails for batch export
+ * @param {string} accessToken
+ * @param {object} query
+ * @param {string|null} [mailbox] - Shared mailbox email, or null for the signed-in user
  */
-async function searchEmailsForExport(accessToken, query) {
+async function searchEmailsForExport(accessToken, query, mailbox = null) {
   const folder = query.folder || 'inbox';
   const maxResults = Math.min(query.maxResults || 25, 100);
 
@@ -483,14 +515,17 @@ async function searchEmailsForExport(accessToken, query) {
     searchParts.push(`subject:${query.subject}`);
   }
   if (searchParts.length > 0) {
-    params.$search = `"${searchParts.join(' ')}"`;
+    params.$search = quoteSearchPhrase(searchParts.join(' '));
     delete params.$orderby; // Can't combine $search with $orderby
   }
 
+  // resolveFolderPath handles well-known names, custom/localized names, nested
+  // paths, and raw IDs, scoped to the signed-in user or the shared mailbox.
+  const endpoint = await resolveFolderPath(accessToken, folder, mailbox);
   const response = await callGraphAPI(
     accessToken,
     'GET',
-    `me/mailFolders/${folder}/messages`,
+    endpoint,
     null,
     params
   );
@@ -507,7 +542,8 @@ async function exportWithConcurrency(
   format,
   outputDir,
   includeAttachments,
-  maxConcurrent
+  maxConcurrent,
+  prefix = 'me'
 ) {
   const results = [];
   const inProgress = new Set();
@@ -525,6 +561,7 @@ async function exportWithConcurrency(
         format,
         outputDir,
         includeAttachments,
+        prefix,
         claimedPaths
       ).then((result) => {
         inProgress.delete(promise);
@@ -553,6 +590,7 @@ async function exportSingleForBatch(
   format,
   outputDir,
   includeAttachments,
+  prefix = 'me',
   claimedPaths
 ) {
   try {
@@ -560,7 +598,7 @@ async function exportSingleForBatch(
     const email = await callGraphAPI(
       accessToken,
       'GET',
-      `me/messages/${emailId}`,
+      `${prefix}/messages/${emailId}`,
       null,
       { $select: selectFields }
     );
@@ -568,16 +606,10 @@ async function exportSingleForBatch(
     const timestamp = filenameTimestamp(email.receivedDateTime);
     const safeSubject = sanitizeFilename(email.subject || 'no-subject');
     const extension = getExtension(format);
-    const filePath = claimUniquePath(
-      outputDir,
-      `${timestamp}_${safeSubject}`,
-      extension,
-      claimedPaths
-    );
 
     let content;
     if (format === EXPORT_FORMATS.MIME || format === EXPORT_FORMATS.EML) {
-      content = await callGraphAPIRaw(accessToken, emailId);
+      content = await callGraphAPIRaw(accessToken, emailId, prefix);
     } else if (format === EXPORT_FORMATS.MARKDOWN) {
       content = formatEmailContent(email, VERBOSITY.FULL, {
         includeHeaders: true,
@@ -586,7 +618,14 @@ async function exportSingleForBatch(
       content = JSON.stringify(email, null, 2);
     }
 
-    fs.writeFileSync(filePath, content, 'utf8');
+    const filePath = writeClaimedFile(
+      outputDir,
+      `${timestamp}_${safeSubject}`,
+      extension,
+      claimedPaths,
+      content,
+      'utf8'
+    );
 
     // Handle attachments if requested
     let attachmentCount = 0;
@@ -595,6 +634,7 @@ async function exportSingleForBatch(
         accessToken,
         emailId,
         outputDir,
+        prefix,
         claimedPaths
       );
       attachmentCount = saved.length;
@@ -618,15 +658,25 @@ async function exportSingleForBatch(
 
 /**
  * Save email attachments to directory
+ * @param {string} accessToken
+ * @param {string} emailId
+ * @param {string} outputDir
+ * @param {string} [prefix] - Mailbox resource prefix (`me` or `users/{email}`)
  */
-async function saveAttachments(accessToken, emailId, outputDir, claimedPaths) {
+async function saveAttachments(
+  accessToken,
+  emailId,
+  outputDir,
+  prefix = 'me',
+  claimedPaths
+) {
   const saved = [];
 
   try {
     const response = await callGraphAPI(
       accessToken,
       'GET',
-      `me/messages/${emailId}/attachments`,
+      `${prefix}/messages/${emailId}/attachments`,
       null,
       { $select: 'id,name,contentBytes,size,contentType' }
     );
@@ -635,20 +685,20 @@ async function saveAttachments(accessToken, emailId, outputDir, claimedPaths) {
 
     for (const att of response.value) {
       if (att.contentBytes) {
-        const safeFilename = sanitizeFilename(att.name || 'attachment');
-        // `emailId.substring(0, 8)` was not a disambiguator: Graph message ids
-        // within one mailbox share a long common prefix, so every message's
-        // `invoice.pdf` resolved to the same path and all but the last were
-        // overwritten. Claim a unique path instead.
+        // The attachment name is sender-controlled (GHSA-755c-c45g-69rv):
+        // reduce it to a safe basename. The per-message tag is derived from a
+        // hash of the id, never the raw caller-supplied id, so it can't carry
+        // path characters; uniqueness comes from the exclusive write.
+        const safeFilename = safeAttachmentFilename(att.name);
         const { base, extension } = splitExtension(safeFilename);
-        const filePath = claimUniquePath(
+        const buffer = Buffer.from(att.contentBytes, 'base64');
+        const filePath = writeClaimedFile(
           outputDir,
-          `${emailId.substring(0, 8)}_${base}`,
+          `${messageTag(emailId)}_${base}`,
           extension,
-          claimedPaths || new Set()
+          claimedPaths,
+          buffer
         );
-        const buffer = Buffer.from(att.contentBytes, 'base64');
-        fs.writeFileSync(filePath, buffer);
         saved.push({
           filename: safeFilename,
           path: filePath,
@@ -681,32 +731,18 @@ function filenameTimestamp(isoDateTime) {
 }
 
 /**
- * Claim a not-yet-used path in `outputDir`, appending `_2`, `_3`, ... until the
- * name is free both on disk and among the paths already claimed in this batch.
- *
- * Silent overwrite is the dangerous part of the collision defect: the exporter
- * reported `Successful N / Failed 0` while messages vanished. Never overwrite —
- * disambiguate instead, and let the caller reconcile via the manifest.
- *
- * The claim is synchronous, so it is atomic with respect to the event loop and
- * safe under the batch exporter's 4-way concurrency even though the write
- * itself happens after an await.
- *
- * @param {string} outputDir - Target directory
- * @param {string} base - Filename without extension
- * @param {string} extension - Extension without a leading dot
- * @param {Set<string>} claimed - Paths already claimed by this batch
- * @returns {string} - An unused absolute path, now claimed
+ * Short, filesystem-safe tag for a message id. Graph ids in one mailbox share
+ * a long common prefix and are caller-supplied, so neither a raw prefix nor
+ * the id itself is usable in a filename.
+ * @param {string} emailId
+ * @returns {string} - 8 hex characters
  */
-function claimUniquePath(outputDir, base, extension, claimed) {
-  let candidate = path.join(outputDir, `${base}.${extension}`);
-  let suffix = 1;
-  while (claimed.has(candidate) || fs.existsSync(candidate)) {
-    suffix += 1;
-    candidate = path.join(outputDir, `${base}_${suffix}.${extension}`);
-  }
-  claimed.add(candidate);
-  return candidate;
+function messageTag(emailId) {
+  return crypto
+    .createHash('sha256')
+    .update(String(emailId))
+    .digest('hex')
+    .slice(0, 8);
 }
 
 /**

package/email/folder-utils.js

@@ -1,8 +1,8 @@
 /**
  * Email folder utilities
  */
-const { callGraphAPI } = require('../utils/graph-api');
-const { resolveFolder } = require('../folder/resolve');
+const { resolveFolder, looksLikeFolderId } = require('../folder/resolve');
+const { buildMailboxPrefix } = require('../utils/mailbox');
 
 /**
  * Cache of folder information to reduce API calls
@@ -46,31 +46,53 @@ const WELL_KNOWN_FOLDERS = {
   outbox: 'me/mailFolders/outbox/messages',
 };
 
+/**
+ * Re-point a `me/...` well-known endpoint at a different mailbox.
+ * @param {string} endpoint - A WELL_KNOWN_FOLDERS value
+ * @param {string} prefix - `me` or `users/{email}`
+ * @returns {string}
+ */
+function scope(endpoint, prefix) {
+  return prefix === 'me' ? endpoint : endpoint.replace(/^me\//, `${prefix}/`);
+}
+
 /**
  * Resolve a folder name to its endpoint path
  * @param {string} accessToken - Access token
  * @param {string} folderName - Folder name to resolve
+ * @param {string|null} [mailbox] - Shared mailbox email, or null for the signed-in user
  * @returns {Promise<string>} - Resolved endpoint path
  */
-async function resolveFolderPath(accessToken, folderName) {
+async function resolveFolderPath(accessToken, folderName, mailbox = null) {
+  const prefix = buildMailboxPrefix(mailbox);
+
   // Default to inbox if no folder specified
   if (!folderName) {
-    return WELL_KNOWN_FOLDERS.inbox;
+    return scope(WELL_KNOWN_FOLDERS.inbox, prefix);
   }
 
   // Check if it's a well-known folder (case-insensitive)
   const lowerFolderName = folderName.toLowerCase();
   if (WELL_KNOWN_FOLDERS[lowerFolderName]) {
     console.error(`Using well-known folder path for "${folderName}"`);
-    return WELL_KNOWN_FOLDERS[lowerFolderName];
+    return scope(WELL_KNOWN_FOLDERS[lowerFolderName], prefix);
+  }
+
+  // A raw folder ID is used as-is, as conversations/export did before name
+  // resolution was added (resolving it as a display name would fail).
+  if (looksLikeFolderId(folderName)) {
+    return `${prefix}/mailFolders/${folderName.trim()}/messages`;
   }
 
   try {
     // Path-aware resolution: supports nested folders ("Parent/Child"),
     // case-insensitive names, and reports ambiguity — the same shared resolver
     // the `folders` tool uses, so search can now scope to nested folders. (#216)
-    const resolved = await resolveFolder(accessToken, { name: folderName });
-    const path = `me/mailFolders/${resolved.id}/messages`;
+    const resolved = await resolveFolder(accessToken, {
+      name: folderName,
+      mailbox,
+    });
+    const path = `${prefix}/mailFolders/${resolved.id}/messages`;
     console.error(`Resolved folder "${folderName}" to path: ${path}`);
     return path;
   } catch (error) {
@@ -88,129 +110,7 @@ async function resolveFolderPath(accessToken, folderName) {
   }
 }
 
-/**
- * Get the ID of a mail folder by its name
- * @param {string} accessToken - Access token
- * @param {string} folderName - Name of the folder to find
- * @returns {Promise<string|null>} - Folder ID or null if not found
- */
-async function getFolderIdByName(accessToken, folderName) {
-  try {
-    // First try with exact match filter
-    console.error(`Looking for folder with name "${folderName}"`);
-    const response = await callGraphAPI(
-      accessToken,
-      'GET',
-      'me/mailFolders',
-      null,
-      { $filter: `displayName eq '${folderName}'` }
-    );
-
-    if (response.value && response.value.length > 0) {
-      console.error(
-        `Found folder "${folderName}" with ID: ${response.value[0].id}`
-      );
-      return response.value[0].id;
-    }
-
-    // If exact match fails, try to get all folders and do a case-insensitive comparison
-    console.error(
-      `No exact match found for "${folderName}", trying case-insensitive search`
-    );
-    const allFoldersResponse = await callGraphAPI(
-      accessToken,
-      'GET',
-      'me/mailFolders',
-      null,
-      { $top: 100 }
-    );
-
-    if (allFoldersResponse.value) {
-      const lowerFolderName = folderName.toLowerCase();
-      const matchingFolder = allFoldersResponse.value.find(
-        (folder) => folder.displayName.toLowerCase() === lowerFolderName
-      );
-
-      if (matchingFolder) {
-        console.error(
-          `Found case-insensitive match for "${folderName}" with ID: ${matchingFolder.id}`
-        );
-        return matchingFolder.id;
-      }
-    }
-
-    console.error(`No folder found matching "${folderName}"`);
-    return null;
-  } catch (error) {
-    console.error(`Error finding folder "${folderName}": ${error.message}`);
-    return null;
-  }
-}
-
-/**
- * Get all mail folders
- * @param {string} accessToken - Access token
- * @returns {Promise<Array>} - Array of folder objects
- */
-async function getAllFolders(accessToken) {
-  try {
-    // Get top-level folders
-    const response = await callGraphAPI(
-      accessToken,
-      'GET',
-      'me/mailFolders',
-      null,
-      {
-        $top: 100,
-        $select:
-          'id,displayName,parentFolderId,childFolderCount,totalItemCount,unreadItemCount',
-      }
-    );
-
-    if (!response.value) {
-      return [];
-    }
-
-    // Get child folders for folders with children
-    const foldersWithChildren = response.value.filter(
-      (f) => f.childFolderCount > 0
-    );
-
-    const childFolderPromises = foldersWithChildren.map(async (folder) => {
-      try {
-        const childResponse = await callGraphAPI(
-          accessToken,
-          'GET',
-          `me/mailFolders/${folder.id}/childFolders`,
-          null,
-          {
-            $select:
-              'id,displayName,parentFolderId,childFolderCount,totalItemCount,unreadItemCount',
-          }
-        );
-
-        return childResponse.value || [];
-      } catch (error) {
-        console.error(
-          `Error getting child folders for "${folder.displayName}": ${error.message}`
-        );
-        return [];
-      }
-    });
-
-    const childFolders = await Promise.all(childFolderPromises);
-
-    // Combine top-level folders and all child folders
-    return [...response.value, ...childFolders.flat()];
-  } catch (error) {
-    console.error(`Error getting all folders: ${error.message}`);
-    return [];
-  }
-}
-
 module.exports = {
   WELL_KNOWN_FOLDERS,
   resolveFolderPath,
-  getFolderIdByName,
-  getAllFolders,
 };