@dawnlit/outlook-bridge 1.0.0

package/dist/windows/bounces.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUndeliverableEmails = cleanUndeliverableEmails;
+exports.collectBouncedRecipients = collectBouncedRecipients;
+exports.readSentRecipientGroups = readSentRecipientGroups;
+// Bounce-backs: finding them, filing them away, and mining them for the
+// addresses that failed.
+const run_1 = require("./run");
+const scripts_1 = require("./scripts");
+const json_1 = require("../shared/json");
+const bounceRules_1 = require("../shared/bounceRules");
+const mail_1 = require("../mail");
+/**
+ * The classifier lists, generated from the shared rules so Windows and macOS
+ * cannot come to disagree about what a bounce is. Emitted once per script,
+ * before the item loop.
+ */
+const BOUNCE_LISTS_PS = `
+$phrases = @(${(0, run_1.psList)(bounceRules_1.BOUNCE_SUBJECT_PHRASES)})
+$daemonAddr = @(${(0, run_1.psList)(bounceRules_1.BOUNCE_DAEMON_ADDRESSES)})
+$daemonName = @(${(0, run_1.psList)(bounceRules_1.BOUNCE_DAEMON_NAMES)})
+`;
+/**
+ * Per-item classifier. Given an Outlook item in `$item` and the account address
+ * (lowercased) in `$targetLc`, sets `$reason` to why it's a bounce ('' if not)
+ * and fills `$failedRcpts` with the recipient addresses parsed from the bounce
+ * body. Also leaves `$subj`/`$sName`/`$sEmail` populated for the caller's report.
+ *
+ * The body is only read once a cheaper signal (class/sender/subject) has already
+ * matched — that ordering is what keeps a large-inbox scan affordable.
+ */
+const BOUNCE_CLASSIFY_PS = `
+$reason = ''
+$failedRcpts = @()
+$subj = ''
+$sName = ''
+$sEmail = ''
+$cls = 0
+try { $cls = [int]$item.Class } catch {}
+if ($cls -eq 43 -or $cls -eq 46) {
+    try { if ($item.Subject) { $subj = [string]$item.Subject } } catch {}
+    $subjLc = $subj.ToLower()
+    try { if ($item.SenderName) { $sName = [string]$item.SenderName } } catch {}
+    $sNameLc = $sName.ToLower()
+    try { if ($item.SenderEmailAddress) { $sEmail = [string]$item.SenderEmailAddress } } catch {}
+    $sEmailLc = $sEmail.ToLower()
+    $msgClass = ''
+    try { $msgClass = [string]$item.MessageClass } catch {}
+    if ($msgClass -like '${bounceRules_1.NDR_MESSAGE_CLASS_PREFIX}*') { $reason = 'Non-delivery report (NDR)' }
+    if ($reason -eq '') { foreach ($d in $daemonAddr) { if ($sEmailLc.Contains($d)) { $reason = 'From mail-delivery system'; break } } }
+    if ($reason -eq '') { foreach ($d in $daemonName) { if ($sNameLc.Contains($d)) { $reason = 'From mail-delivery system'; break } } }
+    if ($reason -eq '') { foreach ($p in $phrases) { if ($subjLc.Contains($p)) { $reason = "Bounce subject phrase: '$p'"; break } } }
+    if ($reason -ne '') {
+        $bodyRaw = ''
+        try { if ($item.Body) { $bodyRaw = [string]$item.Body } } catch {}
+        if ($bodyRaw -ne '') {
+            $mm = [regex]::Matches($bodyRaw, '${bounceRules_1.BODY_ADDRESS_PATTERN}')
+            foreach ($m in $mm) {
+                $addr = $m.Value.ToLower().TrimEnd('.')
+                if ($addr -eq $targetLc) { continue }
+                if ($addr.Contains('mailer-daemon') -or $addr.Contains('postmaster') -or $addr.Contains('mail-daemon')) { continue }
+                if ($failedRcpts -notcontains $addr) { $failedRcpts += $addr }
+                if ($failedRcpts.Count -ge 5) { break }
+            }
+        }
+    }
+}
+`;
+/**
+ * Scan an account's inbox for bounce-back / non-delivery messages — Outlook NDRs,
+ * mail-daemon/postmaster rejections, and "Message blocked"-style Google/O365
+ * failure notices — and, unless previewing, move each to Deleted Items (recoverable).
+ *
+ * Classification is deliberately conservative so ordinary mail that merely
+ * mentions "delivery" is never caught: an item matches only when its
+ * MessageClass is an NDR report, its sender fingerprints as a mail-delivery
+ * daemon/postmaster, or its subject contains a specific bounce phrase.
+ *
+ * Matched item references are snapshotted before any Delete() call — deleting
+ * mutates the folder collection, so deleting mid-enumeration would skip items
+ * (same pattern as sendAllDrafts).
+ */
+async function cleanUndeliverableEmails(emailAccount, daysBack = 30, dryRun = true) {
+    (0, run_1.requireWindows)();
+    const days = (0, mail_1.clamp)(daysBack, 1, 365);
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+$dryRun = ${(0, run_1.psBool)(dryRun)}
+${(0, scripts_1.namedStoreScript)(emailAccount)}
+$inbox = $store.GetDefaultFolder(6)
+$cutoff = (Get-Date).AddDays(-${days}).ToString('MM/dd/yyyy HH:mm')
+$filtered = $inbox.Items.Restrict("[ReceivedTime] >= '$cutoff'")
+${BOUNCE_LISTS_PS}
+$targetLc = $target.ToLower()
+$matched = @()   # snapshot of COM item refs to (optionally) delete afterward
+$report = @()
+$count = $filtered.Count
+for ($i = 1; $i -le $count; $i++) {
+    $item = $null
+    try { $item = $filtered.Item($i) } catch { continue }
+    if ($item -eq $null) { continue }
+${BOUNCE_CLASSIFY_PS}
+    if ($reason -eq '') { continue }
+
+    $rt = ''
+    try { $rt = $item.ReceivedTime.ToString('yyyy-MM-dd HH:mm') } catch {}
+    $report += [PSCustomObject]@{
+        entryId = $item.EntryID
+        subject = $subj.Trim()
+        senderName = $sName
+        senderEmail = $sEmail
+        receivedTime = $rt
+        matchedReason = $reason
+        failedRecipients = @($failedRcpts)
+    }
+    $matched += $item
+}
+
+$deleted = 0
+$failed = @()
+if (-not $dryRun) {
+    foreach ($m in $matched) {
+        $s = ''
+        try { $s = [string]$m.Subject } catch {}
+        try { $m.Delete(); $deleted++ }
+        catch { $failed += [PSCustomObject]@{ subject = $s; error = $_.Exception.Message } }
+    }
+}
+
+[PSCustomObject]@{
+    account = $target
+    scannedDays = ${days}
+    dryRun = $dryRun
+    matchedCount = $report.Count
+    deletedCount = $deleted
+    matched = @($report)
+    failed = @($failed)
+} | ConvertTo-Json -Depth 4
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+    return {
+        account: (0, json_1.str)(parsed.account) || emailAccount,
+        scannedDays: (0, json_1.num)(parsed.scannedDays) || days,
+        dryRun: parsed.dryRun !== false,
+        matchedCount: (0, json_1.num)(parsed.matchedCount),
+        deletedCount: (0, json_1.num)(parsed.deletedCount),
+        matched: (0, json_1.toArray)(parsed.matched).map(m => {
+            const e = (0, json_1.record)(m);
+            return {
+                entryId: (0, json_1.str)(e.entryId),
+                subject: (0, json_1.str)(e.subject),
+                senderName: (0, json_1.str)(e.senderName),
+                senderEmail: (0, json_1.str)(e.senderEmail),
+                receivedTime: (0, json_1.str)(e.receivedTime),
+                matchedReason: (0, json_1.str)(e.matchedReason),
+                failedRecipients: (0, json_1.toArray)(e.failedRecipients).map(json_1.str),
+            };
+        }),
+        failed: (0, json_1.toArray)(parsed.failed).map(f => {
+            const e = (0, json_1.record)(f);
+            return { subject: (0, json_1.str)(e.subject), error: (0, json_1.str)(e.error) };
+        }),
+    };
+}
+/**
+ * Read-only scan of an account's Inbox (and, when scanDeleted, its Deleted Items)
+ * for bounce messages, returning just the deduped set of failed recipient
+ * addresses. Uses the same conservative classifier as cleanUndeliverableEmails.
+ *
+ * Deleted Items is included so this still works after cleanUndeliverableEmails has
+ * already filed the bounces there — the blacklist step doesn't depend on running
+ * before the cleanup. This never deletes anything.
+ */
+async function collectBouncedRecipients(emailAccount, daysBack = 30, scanDeleted = true) {
+    if (process.platform !== 'win32')
+        return [];
+    const days = (0, mail_1.clamp)(daysBack, 1, 365);
+    // 6 = Inbox, 3 = Deleted Items.
+    const folderIds = scanDeleted ? '@(6, 3)' : '@(6)';
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+${scripts_1.DELIVERY_STORE_PS}
+$cutoff = (Get-Date).AddDays(-${days}).ToString('MM/dd/yyyy HH:mm')
+${BOUNCE_LISTS_PS}
+$targetLc = $target.ToLower()
+$found = @{}
+foreach ($fid in ${folderIds}) {
+    $folder = $null
+    try { $folder = $store.GetDefaultFolder($fid) } catch {}
+    if ($folder -eq $null) { continue }
+    $filtered = $folder.Items.Restrict("[ReceivedTime] >= '$cutoff'")
+    $count = $filtered.Count
+    for ($i = 1; $i -le $count; $i++) {
+        $item = $null
+        try { $item = $filtered.Item($i) } catch { continue }
+        if ($item -eq $null) { continue }
+${BOUNCE_CLASSIFY_PS}
+        if ($reason -eq '') { continue }
+        foreach ($a in $failedRcpts) { $found[$a] = $true }
+    }
+}
+ConvertTo-Json @($found.Keys) -Depth 2
+`;
+    return (0, json_1.parseArray)(await (0, run_1.runPowerShell)(script, 300000)).map(json_1.str).filter(Boolean);
+}
+/**
+ * Read the account's Sent Items within the window, returning each mail with the
+ * full SMTP address set it was sent to (To + CC + BCC), newest first. This is how
+ * the "was every address for this contact tried?" question gets answered: where a
+ * blast sends one email per organization addressed to all of its addresses, a sent
+ * message's recipient set IS that organization's full address set.
+ */
+async function readSentRecipientGroups(emailAccount, daysBack = 30, limit = 3000) {
+    if (process.platform !== 'win32')
+        return [];
+    const days = (0, mail_1.clamp)(daysBack, 1, 365);
+    const cap = (0, mail_1.clamp)(limit, 1, 10000);
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+$sent = $account.DeliveryStore.GetDefaultFolder(5)  # olFolderSentMail
+$cutoff = (Get-Date).AddDays(-${days}).ToString('MM/dd/yyyy HH:mm')
+$items = $sent.Items.Restrict("[SentOn] >= '$cutoff'")
+$items.Sort('[SentOn]', $true)
+$results = @()
+$count = [Math]::Min($items.Count, ${cap})
+for ($i = 1; $i -le $count; $i++) {
+    $m = $null
+    try { $m = $items.Item($i) } catch { continue }
+    if ($m -eq $null) { continue }
+    $cls = 0
+    try { $cls = [int]$m.Class } catch {}
+    if ($cls -ne 43) { continue }  # olMail only
+    $addrs = @()
+    try {
+        foreach ($r in $m.Recipients) {
+            $addr = ''
+            try { $addr = [string]$r.Address } catch {}
+            # Internal recipients resolve to an Exchange DN, not SMTP — recover the
+            # real address so external correlation still works.
+            if ($addr -notlike '*@*') {
+                try { $addr = [string]$r.AddressEntry.GetExchangeUser().PrimarySmtpAddress } catch {}
+            }
+            if ($addr -like '*@*') { $addrs += $addr.ToLower() }
+        }
+    } catch {}
+    if ($addrs.Count -eq 0) { continue }
+    $sentOn = ''
+    try { $sentOn = $m.SentOn.ToString('yyyy-MM-dd HH:mm') } catch {}
+    $subj = ''
+    try { if ($m.Subject) { $subj = [string]$m.Subject } } catch {}
+    $results += [PSCustomObject]@{
+        entryId = $m.EntryID
+        subject = $subj.Trim()
+        sentOn = $sentOn
+        recipients = @($addrs)
+    }
+}
+ConvertTo-Json @($results) -Depth 4
+`;
+    return (0, json_1.parseArray)(await (0, run_1.runPowerShell)(script, 300000)).map(it => {
+        const e = (0, json_1.record)(it);
+        return {
+            entryId: (0, json_1.str)(e.entryId),
+            subject: (0, json_1.str)(e.subject),
+            sentOn: (0, json_1.str)(e.sentOn),
+            recipients: (0, json_1.toArray)(e.recipients).map(json_1.str),
+        };
+    });
+}
+//# sourceMappingURL=bounces.js.map

package/dist/windows/bounces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounces.js","sourceRoot":"","sources":["../../src/windows/bounces.ts"],"names":[],"mappings":";;AAuFA,4DAoFC;AAWD,4DAiCC;AASD,0DA0DC;AA1RD,wEAAwE;AACxE,yBAAyB;AACzB,+BAAsE;AACtE,uCAA+E;AAC/E,yCAAoF;AACpF,uDAM+B;AAC/B,kCAAgC;AAGhC;;;;GAIG;AACH,MAAM,eAAe,GAAG;eACT,IAAA,YAAM,EAAC,oCAAsB,CAAC;kBAC3B,IAAA,YAAM,EAAC,qCAAuB,CAAC;kBAC/B,IAAA,YAAM,EAAC,iCAAmB,CAAC;CAC5C,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;2BAiBA,sCAAwB;;;;;;;;gDAQH,kCAAoB;;;;;;;;;;;CAWnE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACI,KAAK,UAAU,wBAAwB,CAC1C,YAAoB,EACpB,QAAQ,GAAG,EAAE,EACb,MAAM,GAAG,IAAI;IAEb,IAAA,oBAAc,GAAE,CAAC;IACjB,MAAM,IAAI,GAAG,IAAA,YAAK,EAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IACrC,MAAM,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,YAAY,CAAC;YACrC,IAAA,YAAM,EAAC,MAAM,CAAC;EACxB,IAAA,0BAAgB,EAAC,YAAY,CAAC;;gCAEA,IAAI;;EAElC,eAAe;;;;;;;;;EASf,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8BA,IAAI;;;;;;;CAOvB,CAAC;IACE,MAAM,MAAM,GAAG,IAAA,kBAAW,EAAC,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,OAAO;QACH,OAAO,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,OAAO,CAAC,IAAI,YAAY;QAC5C,WAAW,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,WAAW,CAAC,IAAI,IAAI;QAC5C,MAAM,EAAE,MAAM,CAAC,MAAM,KAAK,KAAK;QAC/B,YAAY,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,YAAY,CAAC;QACtC,YAAY,EAAE,IAAA,UAAG,EAAC,MAAM,CAAC,YAAY,CAAC;QACtC,OAAO,EAAE,IAAA,cAAO,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACrC,MAAM,CAAC,GAAG,IAAA,aAAM,EAAC,CAAC,CAAC,CAAC;YACpB,OAAO;gBACH,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC;gBACvB,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC;gBACvB,UAAU,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,UAAU,CAAC;gBAC7B,WAAW,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,WAAW,CAAC;gBAC/B,YAAY,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,YAAY,CAAC;gBACjC,aAAa,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,aAAa,CAAC;gBACnC,gBAAgB,EAAE,IAAA,cAAO,EAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,UAAG,CAAC;aACzD,CAAC;QACN,CAAC,CAAC;QACF,MAAM,EAAE,IAAA,cAAO,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACnC,MAAM,CAAC,GAAG,IAAA,aAAM,EAAC,CAAC,CAAC,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5D,CAAC,CAAC;KACL,CAAC;AACN,CAAC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,wBAAwB,CAC1C,YAAoB,EACpB,QAAQ,GAAG,EAAE,EACb,WAAW,GAAG,IAAI;IAElB,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,EAAE,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAA,YAAK,EAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IACrC,gCAAgC;IAChC,MAAM,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;IACnD,MAAM,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,YAAY,CAAC;EAC/C,2BAAiB;gCACa,IAAI;EAClC,eAAe;;;mBAGE,SAAS;;;;;;;;;;EAU1B,kBAAkB;;;;;;CAMnB,CAAC;IACE,OAAO,IAAA,iBAAU,EAAC,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,UAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACpF,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,uBAAuB,CACzC,YAAoB,EACpB,QAAQ,GAAG,EAAE,EACb,KAAK,GAAG,IAAI;IAEZ,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,EAAE,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAA,YAAK,EAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,IAAA,YAAK,EAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,GAAG,IAAA,uBAAa,EAAC,YAAY,CAAC;;gCAEjB,IAAI;;;;qCAIC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCvC,CAAC;IACE,OAAO,IAAA,iBAAU,EAAC,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;QAC5D,MAAM,CAAC,GAAG,IAAA,aAAM,EAAC,EAAE,CAAC,CAAC;QACrB,OAAO;YACH,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC;YACvB,OAAO,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,OAAO,CAAC;YACvB,MAAM,EAAE,IAAA,UAAG,EAAC,CAAC,CAAC,MAAM,CAAC;YACrB,UAAU,EAAE,IAAA,cAAO,EAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,UAAG,CAAC;SAC7C,CAAC;IACN,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/windows/cleanup.d.ts

@@ -0,0 +1,29 @@
+import type { DeleteMailOptions, DeleteMailResult, PurgeDeletedItemsResult } from '../types';
+/**
+ * Delete mail by EntryID from anywhere in the account. Delete() moves each item to
+ * Deleted Items, so this is recoverable — purgeDeletedItems is what destroys.
+ *
+ * ⚠️ This is the one tool here that can reach received mail, and EntryIDs are a
+ * genuinely unsafe key for it: GetItemFromID silently returns a DIFFERENT message
+ * when handed a stale or wrong id, which is common precisely when many replies share
+ * one subject (see saveEmailAttachmentDetailed). Three things hold the line:
+ *
+ *  - **Inbox and Sent Items are refused by default, INCLUDING their subfolders** —
+ *    a filed subfolder is still received mail. `allowProtected` lifts that, and is
+ *    the caller explicitly taking responsibility.
+ *  - **`dryRun` resolves and reports without deleting**, so the exact subjects and
+ *    folders can be shown to the user before anything happens. Use it first.
+ *  - **Every outcome echoes the subject and folderPath** of the item actually
+ *    resolved, so a wrong id is visible after the fact rather than silent.
+ */
+export declare function deleteOutlookEmails(emailAccount: string, entryIds: string[], options?: DeleteMailOptions): Promise<DeleteMailResult>;
+/**
+ * Permanently remove items from the account's Deleted Items folder. This is the ONE
+ * genuinely irreversible operation here — nothing recovers from it — which is why it
+ * is folder-scoped rather than keyed on an EntryID: it can only ever destroy what the
+ * user already threw away.
+ *
+ * `olderThanDays` keeps recent items (0 = purge everything). Iterates backwards, as
+ * deleting mutates the collection and a forward walk would skip every other item.
+ */
+export declare function purgeDeletedItems(emailAccount: string, olderThanDays?: number, dryRun?: boolean): Promise<PurgeDeletedItemsResult>;

package/dist/windows/cleanup.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOutlookEmails = deleteOutlookEmails;
+exports.purgeDeletedItems = purgeDeletedItems;
+// Deleting mail, and emptying what was already deleted.
+const run_1 = require("./run");
+const scripts_1 = require("./scripts");
+const json_1 = require("../shared/json");
+const mail_1 = require("../mail");
+/** Folders whose contents are received or already-sent mail, not working state. */
+const PROTECTED_FOLDER_IDS = [6, 5];
+/** Walks an item's parent chain, so Inbox/Sent protection covers their subfolders too. */
+const FOLDER_CHAIN_PS = `
+function Get-FolderChainIds($folder) {
+    $ids = @()
+    $cur = $folder
+    $guard = 0
+    while ($cur -ne $null -and $guard -lt 25) {
+        $cid = $null
+        try { $cid = $cur.EntryID } catch { $cid = $null }
+        if (-not $cid) { break }
+        $ids += $cid
+        $parent = $null
+        try { $parent = $cur.Parent } catch { $parent = $null }
+        if ($parent -eq $null) { break }
+        $cur = $parent
+        $guard++
+    }
+    return $ids
+}
+`;
+/**
+ * Delete mail by EntryID from anywhere in the account. Delete() moves each item to
+ * Deleted Items, so this is recoverable — purgeDeletedItems is what destroys.
+ *
+ * ⚠️ This is the one tool here that can reach received mail, and EntryIDs are a
+ * genuinely unsafe key for it: GetItemFromID silently returns a DIFFERENT message
+ * when handed a stale or wrong id, which is common precisely when many replies share
+ * one subject (see saveEmailAttachmentDetailed). Three things hold the line:
+ *
+ *  - **Inbox and Sent Items are refused by default, INCLUDING their subfolders** —
+ *    a filed subfolder is still received mail. `allowProtected` lifts that, and is
+ *    the caller explicitly taking responsibility.
+ *  - **`dryRun` resolves and reports without deleting**, so the exact subjects and
+ *    folders can be shown to the user before anything happens. Use it first.
+ *  - **Every outcome echoes the subject and folderPath** of the item actually
+ *    resolved, so a wrong id is visible after the fact rather than silent.
+ */
+async function deleteOutlookEmails(emailAccount, entryIds, options = {}) {
+    (0, run_1.requireWindows)();
+    const { allowProtected = false, dryRun = false } = options;
+    if (entryIds.length === 0) {
+        return { dryRun, deleted: 0, refused: 0, failed: 0, items: [] };
+    }
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+${scripts_1.DELIVERY_STORE_PS}
+${FOLDER_CHAIN_PS}
+$protectedIds = @{}
+foreach ($fid in @(${PROTECTED_FOLDER_IDS.join(',')})) {
+    try { $protectedIds[$store.GetDefaultFolder($fid).EntryID] = $true } catch {}
+}
+
+$items = @()
+$deleted = 0
+$refused = 0
+$failed = 0
+foreach ($id in @(${(0, run_1.psList)(entryIds)})) {
+    $subject = ''
+    $folderPath = ''
+    try {
+        $it = $null
+        try { $it = $ns.GetItemFromID($id, $store.StoreID) } catch { $it = $null }
+        if ($it -eq $null) { try { $it = $ns.GetItemFromID($id) } catch { $it = $null } }
+        if ($it -eq $null) { throw "no item with that EntryID in this account" }
+        try { $subject = $it.Subject } catch {}
+        $parent = $null
+        try { $parent = $it.Parent } catch {}
+        if ($parent -eq $null) { throw "item has no parent folder - refusing to delete" }
+        try { $folderPath = $parent.FolderPath } catch {}
+
+        $chain = Get-FolderChainIds $parent
+        $isProtected = $false
+        foreach ($cid in $chain) { if ($protectedIds.ContainsKey($cid)) { $isProtected = $true; break } }
+
+        if ($isProtected -and -not ${(0, run_1.psBool)(allowProtected)}) {
+            $refused++
+            $items += [pscustomobject]@{ entryId = $id; subject = $subject; folderPath = $folderPath; status = 'refused'; reason = '${(0, run_1.psEscape)(mail_1.PROTECTED_MAIL_REASON)}' }
+        } elseif (${(0, run_1.psBool)(dryRun)}) {
+            $items += [pscustomobject]@{ entryId = $id; subject = $subject; folderPath = $folderPath; status = 'would-delete'; reason = '' }
+        } else {
+            $it.Delete()
+            $deleted++
+            $items += [pscustomobject]@{ entryId = $id; subject = $subject; folderPath = $folderPath; status = 'deleted'; reason = '' }
+        }
+    } catch {
+        $failed++
+        $items += [pscustomobject]@{ entryId = $id; subject = $subject; folderPath = $folderPath; status = 'failed'; reason = $_.Exception.Message }
+    }
+}
+ConvertTo-Json @{ dryRun = ${(0, run_1.psBool)(dryRun)}; deleted = $deleted; refused = $refused; failed = $failed; items = @($items) } -Depth 4
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 300000));
+    return {
+        dryRun,
+        deleted: (0, json_1.num)(parsed.deleted),
+        refused: (0, json_1.num)(parsed.refused),
+        failed: (0, json_1.num)(parsed.failed),
+        items: (0, json_1.toArray)(parsed.items).map(i => {
+            const e = (0, json_1.record)(i);
+            return {
+                entryId: (0, json_1.str)(e.entryId),
+                subject: (0, json_1.str)(e.subject),
+                folderPath: (0, json_1.str)(e.folderPath),
+                status: ((0, json_1.str)(e.status) || 'failed'),
+                reason: (0, json_1.str)(e.reason),
+            };
+        }),
+    };
+}
+/**
+ * Permanently remove items from the account's Deleted Items folder. This is the ONE
+ * genuinely irreversible operation here — nothing recovers from it — which is why it
+ * is folder-scoped rather than keyed on an EntryID: it can only ever destroy what the
+ * user already threw away.
+ *
+ * `olderThanDays` keeps recent items (0 = purge everything). Iterates backwards, as
+ * deleting mutates the collection and a forward walk would skip every other item.
+ */
+async function purgeDeletedItems(emailAccount, olderThanDays = 0, dryRun = false) {
+    (0, run_1.requireWindows)();
+    const script = `${(0, scripts_1.accountScript)(emailAccount)}
+$folder = $account.DeliveryStore.GetDefaultFolder(3)
+$cutoff = (Get-Date).AddDays(-${olderThanDays})
+$matched = 0
+$purged = 0
+$kept = 0
+$failed = 0
+# Bound once: every $folder.Items is a COM property get that materialises a
+# fresh collection object, and this loop runs once per message in Deleted Items.
+$folderItems = $folder.Items
+for ($i = $folderItems.Count; $i -ge 1; $i--) {
+    $it = $null
+    try { $it = $folderItems.Item($i) } catch { continue }
+    $stamp = $null
+    foreach ($p in @('ReceivedTime','LastModificationTime','CreationTime')) {
+        try { $stamp = $it.$p; if ($stamp -ne $null) { break } } catch {}
+    }
+    if (${olderThanDays} -gt 0 -and $stamp -ne $null -and $stamp -gt $cutoff) { $kept++; continue }
+    $matched++
+    if (${(0, run_1.psBool)(dryRun)}) { continue }
+    try { $it.Delete(); $purged++ } catch { $failed++ }
+}
+ConvertTo-Json @{ folderPath = $folder.FolderPath; matched = $matched; purged = $purged; kept = $kept; failed = $failed } -Depth 3
+`;
+    const parsed = (0, json_1.parseObject)(await (0, run_1.runPowerShell)(script, 600000));
+    return {
+        folderPath: (0, json_1.str)(parsed.folderPath),
+        dryRun,
+        matched: (0, json_1.num)(parsed.matched),
+        purged: (0, json_1.num)(parsed.purged),
+        kept: (0, json_1.num)(parsed.kept),
+        failed: (0, json_1.num)(parsed.failed),
+    };
+}
+//# sourceMappingURL=cleanup.js.map

package/dist/windows/cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.js","sourceRoot":"","sources":["../../src/windows/cleanup.ts"],"names":[],"mappings":"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"}

package/dist/windows/drafts.d.ts

@@ -0,0 +1,29 @@
+import type { DeleteDraftsResult, ListDraftsResult, SendAllDraftsResult } from '../types';
+/**
+ * Send the mail drafts that belong to `emailAccount`, wherever Outlook filed them.
+ * Which drafts those are is DRAFTS_SCAN_PS's rule, not this function's.
+ *
+ * Item references are snapshotted before any Send() call: sending moves an item out
+ * of Drafts, and mutating the collection mid-enumeration would skip every other one.
+ */
+export declare function sendAllDrafts(emailAccount: string): Promise<SendAllDraftsResult>;
+/**
+ * List the mail drafts belonging to `emailAccount`, newest first. Which drafts
+ * those are is DRAFTS_SCAN_PS's rule.
+ *
+ * Deliberately returns no StoreID: deleteOutlookDrafts re-resolves each EntryID
+ * against the same folders, so repeating a ~700-char store id on every row would be
+ * pure payload. Bodies are previewed, never returned whole — a templated reply body
+ * runs to tens of thousands of characters and a folder's worth would blow the cap.
+ */
+export declare function listOutlookDrafts(emailAccount: string, limit?: number, previewChars?: number): Promise<ListDraftsResult>;
+/**
+ * Delete mail drafts by EntryID. Outlook's Delete() moves the item to Deleted Items
+ * rather than destroying it, so a mistaken call stays recoverable from there.
+ *
+ * Every id must resolve to a mail item sitting in one of THIS account's Drafts
+ * folders before anything is deleted; an id pointing at ordinary mail, or at another
+ * account's draft, is refused and reported. Without that gate this would be a
+ * general-purpose "delete any email by id" tool, which is not what it is for.
+ */
+export declare function deleteOutlookDrafts(emailAccount: string, entryIds: string[]): Promise<DeleteDraftsResult>;