@dawnlit/outlook-bridge 1.0.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing
+      the origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Dawnlit
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,253 @@
+# @dawnlit/outlook-bridge
+
+Drive a real, locally installed Outlook client from Node — read the inbox, send and reply to mail, manage drafts, work
+with signatures and template emails, file and delete messages. No Graph API, no app registration, no cloud permissions:
+this automates the desktop client itself, the same way a person would.
+
+- **Windows** — via PowerShell + Outlook's COM object model.
+- **macOS** — via AppleScript. The whole surface is ported, with two differences no capability flag can express (see
+  [Platform differences](#platform-differences)). Requires **legacy** Outlook for Mac: New Outlook implements only a
+  slice of the AppleScript dictionary — accounts don't enumerate and the inbox reports 0 messages — so calls fail
+  loudly with `ACCOUNT_NOT_FOUND` there rather than quietly doing the wrong thing.
+- Any other platform — `capabilities()` reports everything false and every call rejects with `UNSUPPORTED_PLATFORM`.
+
+## Install
+
+Install straight off GitHub `main`, rather than a versioned release:
+
+```bash
+npm install github:dawnlit-ai/outlook-bridge#main
+```
+
+`prepare` runs `npm run build` automatically on install, so `dist/` is built from that checked-out
+source with no separate step. npm resolves the branch to a commit and pins it in `package-lock.json`,
+so a later plain `npm install` won't pick up new commits on its own — re-run the command above
+(naming the package and `#main` explicitly) whenever you want to advance to the current tip.
+
+Requires Node 24+ and a real Outlook installation on the machine running it — this is desktop automation, not a hosted
+API client.
+
+## Usage
+
+```ts
+import { getOutlookAccounts, readInboxEmails, sendOutlookEmail } from '@dawnlit/outlook-bridge';
+
+const accounts = await getOutlookAccounts();
+
+const emails = await readInboxEmails(accounts[0]);
+
+await sendOutlookEmail({
+    emailAccount: accounts[0],
+    to: 'someone@example.com',          // comma- or semicolon-separated
+    subject: 'Hello from @dawnlit/outlook-bridge',
+    htmlBody: '<p>Sent by driving the Outlook client directly.</p>',
+    sendImmediately: false,             // false leaves it in Drafts
+});
+```
+
+Every function is exposed under one signature regardless of platform — the dispatcher pins both implementations to the
+same `OutlookBridge` interface, so nothing here returns a per-platform union you have to narrow.
+
+## Platform differences
+
+Both platforms implement the whole contract, so `capabilities()` is all-true on Windows and on macOS. It still exists,
+and is still worth asking, because it answers for the machine you are actually on — on any other OS every entry is
+false and every call rejects:
+
+```ts
+import { createOutlookBridge } from '@dawnlit/outlook-bridge';
+
+const bridge = createOutlookBridge();
+
+if (bridge.supports('searchInboxByFilter')) { /* … */ }
+
+bridge.capabilities(); // { readInboxEmails: true, replyOutlookEmail: true, … }
+```
+
+The map is derived from `keyof OutlookBridge`, so a function added to the contract fails both platform maps at
+compile time rather than quietly defaulting to supported.
+
+Two things differ between the platforms that no flag can express, and code moving between them has to know both:
+
+**Ids are not portable.** Windows returns MAPI `EntryID` strings; macOS returns Outlook for Mac's small integer message
+ids (`"1263"`). Each platform rejects the other's with `INVALID_REQUEST` rather than failing later as a confusing "not
+found". `storeId` has no macOS equivalent: it is returned as `''` and accepted-and-ignored wherever it is a parameter.
+Don't persist an id from one platform and look it up on the other.
+
+**`searchInboxByFilter` filters in-process on macOS.** Windows hands `subjectLike` and the date window to Outlook's
+server-side `Items.Restrict`; AppleScript has no counterpart, so the macOS walk indexes each folder with bulk property
+reads and applies the same tests here. Same results, different cost — a `daysBack` of 0 over a large mailbox tree is
+considerably heavier on macOS.
+
+Two smaller notes: `replyOutlookEmail` reports `to` as the reply's resolved recipient addresses on macOS rather than the
+display-name string Windows reports; and `editEmailTemplate` on macOS files the edited draft when you answer Outlook's
+own "save this message?" prompt on close, where Windows asks for Ctrl+S.
+
+## Configuration
+
+Each call generates a script and shells out to an interpreter. That leaves four things otherwise out of your reach:
+how long a run may take, how much it may print, how to call it off, and what the script actually said.
+
+`createOutlookBridge()` gives you those on an instance no other caller in the process can disturb:
+
+```ts
+import { createOutlookBridge } from '@dawnlit/outlook-bridge';
+
+const bridge = createOutlookBridge({
+    timeoutMs: 120_000,               // default per-run ceiling; 0 disables
+    maxBufferBytes: 32 * 1024 * 1024, // raise before a scan that returns thousands of bodies
+    tempDir: '/var/tmp/outlook',      // scratch scripts and default attachment destination
+    debug: (e) => log(e.script),      // every generated script, its duration, and any error
+});
+
+await bridge.readInboxEmails(account);
+```
+
+`bridge.withOptions({ … })` derives a bridge with some settings changed — how one call gets its own budget, or its
+own cancellation:
+
+```ts
+const controller = new AbortController();
+cancelButton.onclick = () => controller.abort();
+
+await bridge.withOptions({ signal: controller.signal }).searchInboxByFilter(account, filter);
+// → rejects with an AbortedError (code 'ABORTED'), interpreter killed
+```
+
+The same functions are also exported directly, running against a process-wide config that `configure()` sets. That is
+the simpler thing for a program that owns its process; prefer `createOutlookBridge` in anything sharing a process
+with code you do not own.
+
+```ts
+import { configure, readInboxEmails } from '@dawnlit/outlook-bridge';
+
+configure({ timeoutMs: 60_000 });
+await readInboxEmails(account);
+```
+
+`OUTLOOK_BRIDGE_DEBUG=1` in the environment turns on script logging to stderr without a code change.
+
+Calls that carry a genuinely different budget (a full-mailbox walk, a purge) keep their own timeout and ignore
+`timeoutMs`. `searchInboxByFilter` is the one most likely to push against `maxBufferBytes`, since it returns whole
+message bodies.
+
+## Errors
+
+Every deliberate failure is an `OutlookError` carrying a stable `code`. **The codes are the API; the messages are
+not** — branch on `code`, never on message text.
+
+```ts
+import { OutlookError } from '@dawnlit/outlook-bridge';
+
+try {
+    await bridge.replyOutlookEmail(params);
+} catch (error) {
+    if (!(error instanceof OutlookError)) throw error; // a real bug
+    switch (error.code) {
+        case 'ACCOUNT_NOT_FOUND': return promptForAccount(error.account);
+        case 'NOT_IMPLEMENTED':   return degrade(error.operation);
+        case 'ABORTED':           return;
+        case 'SCRIPT_FAILED':     return report(error.script, error.stderr);
+    }
+}
+```
+
+| code | class | meaning |
+| --- | --- | --- |
+| `UNSUPPORTED_PLATFORM` | `UnsupportedPlatformError` | No Outlook automation exists on this OS. |
+| `NOT_IMPLEMENTED` | `NotImplementedError` | The platform could, but this corner isn't written. Carries `operation`. Now only reachable for a folder root macOS has no term for (Journal and the like). |
+| `ACCOUNT_NOT_FOUND` | `AccountNotFoundError` | No configured account matches. Carries `account`. |
+| `NOT_FOUND` | `NotFoundError` | A folder, template, signature or item did not resolve. Carries `kind`. |
+| `INVALID_REQUEST` | `InvalidRequestError` | The arguments cannot produce a call; nothing was attempted. |
+| `SCRIPT_FAILED` | `ScriptError` | The interpreter ran and failed. Carries `script`, `stderr`, `runner`, `durationMs`. |
+| `TIMEOUT` | `TimeoutError` | The run exceeded its budget and was killed. Carries `timeoutMs`. |
+| `ABORTED` | `AbortedError` | The caller's `AbortSignal` fired. |
+
+`ScriptError` carries the generated script verbatim — the thing you actually want when one fires, and otherwise
+reachable only if you wired up a `debug` hook in advance.
+
+## Module format
+
+Published as CommonJS. ESM consumers can use named imports normally (`import { sendOutlookEmail } from …`); Node
+resolves them off the CJS build.
+
+There is deliberately no dual ESM/CJS build. This package identifies its errors with `instanceof`, and a dual-format
+package can load two copies of itself into one process — at which point `error instanceof OutlookError` returns
+`false` for errors the package itself threw. One format avoids that failure entirely.
+
+## API
+
+**Accounts & inbox** — `getOutlookAccounts`, `readInboxEmails`, `readEmailBody`,
+`listInboxFolders`, `moveOutlookEmails`, `openOutlookEmail`.
+
+**Search & selection** — `searchInboxByFilter` (walks every folder under the Inbox for one
+account, filtering by subject pattern/date window/reply-exclusion/attachment presence — the
+building block for "find the emails matching X" without knowing which subfolder holds them),
+`readSelectedEmail` (the email currently selected or open in Outlook).
+
+**Sending & replying** — `sendOutlookEmail`, `replyOutlookEmail` (answers the sender; pass `replyAll: true` to answer
+every recipient), `sendAllDrafts`.
+
+**Drafts** — `listOutlookDrafts`, `deleteOutlookDrafts`.
+
+**Attachments** — `saveEmailAttachment`, `saveEmailAttachmentDetailed`, `saveEmailAttachments`
+(the same, batched into one COM round trip for several attachments off one email). All take an optional `destDir`,
+created if absent. Without one, each call saves into a fresh private directory — attachments keep the name the sender
+gave them, so a shared folder means two emails carrying `invoice.pdf` overwrite each other.
+
+**Signatures & templates** — `listOutlookSignatures`, `readOutlookSignatureHtml`,
+`readTemplateEmails`, `saveTemplateEmail`, `editEmailTemplate` (opens the template in a real Outlook compose window,
+waits for the user to close it, and returns the saved HTML — so it has no timeout by default; give it an
+`AbortSignal` if you need a way to give up).
+
+**Bounce handling** — `cleanUndeliverableEmails`, `collectBouncedRecipients`,
+`readSentRecipientGroups`.
+
+**Mailbox cleanup** — `deleteOutlookEmails`, `purgeDeletedItems`.
+
+**Template-section parsing** — a small pure-string toolkit for templates that carry several reply variants between
+`[[SECTION]] ... [[/SECTION]]` markers around one shared greeting/signature, with `{{PLACEHOLDER}}` tokens filled in by
+the caller: `findTemplateMarkers`, `composeTemplateBody`, `findTokens`,
+`findUnfilledTokens`, `replaceToken`, `removeTokenLine`.
+
+**Platform-neutral helpers** — usable with no Outlook session at all: `mailFolderRef` (parse any folder string a user
+might type into a well-known root plus segments), `splitQuotedOriginal` (separate a reply's own text from the thread
+quoted below it), `WELL_KNOWN_FOLDERS`.
+
+**Instances, capabilities and errors** — `createOutlookBridge` (a bridge with its own settings; see
+[Configuration](#configuration)), `capabilities` / `supports`, and the `OutlookError` family
+(see [Errors](#errors)).
+
+Every exported type (`InboxEmail`, `ReplyEmailParams`, `MailFolderRef`, `OutlookBridge`, `CapabilityMap`,
+`OutlookErrorCode`, etc.) is exported alongside its function.
+
+## Development
+
+```bash
+npm run build   # tsc → dist/
+npm test        # build, then node:test over the platform-independent parts
+```
+
+The tests cover the parts that need no Outlook session — folder-string parsing, quote splitting, template
+composition, scratch-file handling, the error taxonomy and its run classifier, capability maps, config scoping, and
+the shape of the PowerShell the folder walk emits — so they run anywhere, with or without Outlook installed.
+
+On a **Mac with Outlook installed** they additionally compile every AppleScript the macOS implementation generates.
+The runner is stubbed, each operation is driven with plausible arguments, and the captured scripts go through
+`osacompile` — which resolves terminology against the real dictionary without opening a session, sending anything or
+touching a message. This is worth the trouble because one bad dictionary term fails the WHOLE script at compile time
+rather than at the offending line, so a live failure never names the thing that caused it. Those tests skip
+automatically elsewhere.
+
+Two guards over the same captured scripts run **everywhere**, with no Outlook needed, because they cover the
+failures compiling cannot catch — both of which shipped once and only surfaced against a live mailbox: assigning to a
+reserved AppleScript word (`set rest to …` parses, then fails at run time), and reading a record field through a
+nested accessor (`address of (sender of m)` does not coerce, and inside a `try` that means a silently empty sender).
+
+What no test can cover is the automation itself: driving a real Outlook client is the whole point of the package, and
+behaviour against a live mailbox — that a `move` really filed the mail, that a reply threaded correctly — is verified
+by running it, not in CI.
+
+## License
+
+Apache-2.0 © Dawnlit

package/dist/OutlookService.d.ts

@@ -0,0 +1,43 @@
+import type { BridgeOptions, ResolvedConfig } from './runtime';
+import type { BridgeCapability, CapabilityMap, OutlookBridge } from './types';
+/** Which operations work on this machine. See `CapabilityMap`. */
+export declare function capabilities(): CapabilityMap;
+/** Whether one operation works here — `capabilities()` for a single name. */
+export declare function supports(operation: BridgeCapability): boolean;
+/**
+ * An Outlook bridge carrying its own settings, plus capability discovery.
+ *
+ * The free functions exported below are the same automation against the
+ * process-wide config; this is what you want when the process holds more than
+ * one caller, or when a call needs its own timeout or AbortSignal.
+ */
+export interface OutlookBridgeInstance extends OutlookBridge {
+    /** The settings this instance runs with. */
+    readonly options: Readonly<ResolvedConfig>;
+    /** Which operations work on this machine. */
+    capabilities(): CapabilityMap;
+    /** Whether one operation works here. */
+    supports(operation: BridgeCapability): boolean;
+    /**
+     * A bridge like this one with some settings changed — the per-call escape
+     * hatch, and how a cancellable call is made:
+     * `bridge.withOptions({ signal }).searchInboxByFilter(...)`.
+     */
+    withOptions(options: BridgeOptions): OutlookBridgeInstance;
+}
+/**
+ * A bridge with its own settings, isolated from `configure()` and from every
+ * other instance.
+ *
+ * ```ts
+ * const bridge = createOutlookBridge({ timeoutMs: 30_000 });
+ * if (bridge.supports('searchInboxByFilter')) {
+ *     await bridge.withOptions({ signal }).searchInboxByFilter(account, filter);
+ * }
+ * ```
+ *
+ * Options left out fall back to the process-wide values as they stand when this
+ * is called.
+ */
+export declare function createOutlookBridge(options?: BridgeOptions): OutlookBridgeInstance;
+export declare const getOutlookAccounts: () => Promise<string[]>, sendOutlookEmail: (params: import("./types").SendEmailParams) => Promise<void>, replyOutlookEmail: (params: import("./types").ReplyEmailParams) => Promise<import("./types").ReplyEmailResult>, sendAllDrafts: (emailAccount: string) => Promise<import("./types").SendAllDraftsResult>, readInboxEmails: (emailAccount: string, daysBack?: number, limit?: number, folder?: string) => Promise<import("./types").InboxEmail[]>, searchInboxByFilter: (emailAccount: string, filter?: import("./types").InboxSearchFilter, daysBack?: number) => Promise<import("./types").InboxSearchMatch[]>, readSelectedEmail: () => Promise<import("./types").SelectedEmail>, readEmailBody: (entryId: string, storeId?: string, maxChars?: number, includeQuoted?: boolean) => Promise<import("./types").EmailBodyResult>, openOutlookEmail: (entryId: string) => Promise<void>, listInboxFolders: (emailAccount: string, maxDepth?: number) => Promise<import("./types").InboxFolderInfo[]>, moveOutlookEmails: (emailAccount: string, entryIds: string[], folderName: string, createIfMissing?: boolean) => Promise<import("./types").MoveEmailsResult>, listOutlookDrafts: (emailAccount: string, limit?: number, previewChars?: number) => Promise<import("./types").ListDraftsResult>, deleteOutlookDrafts: (emailAccount: string, entryIds: string[]) => Promise<import("./types").DeleteDraftsResult>, deleteOutlookEmails: (emailAccount: string, entryIds: string[], options?: import("./types").DeleteMailOptions) => Promise<import("./types").DeleteMailResult>, purgeDeletedItems: (emailAccount: string, olderThanDays?: number, dryRun?: boolean) => Promise<import("./types").PurgeDeletedItemsResult>, saveEmailAttachment: (entryId: string, fileName: string, storeId?: string, destDir?: string) => Promise<string>, saveEmailAttachmentDetailed: (entryId: string, fileName: string, storeId?: string, destDir?: string) => Promise<import("./types").SavedAttachment>, saveEmailAttachments: (entryId: string, fileNames: string[], storeId?: string, destDir?: string) => Promise<import("./types").SavedAttachment[]>, cleanUndeliverableEmails: (emailAccount: string, daysBack?: number, dryRun?: boolean) => Promise<import("./types").CleanUndeliverableResult>, collectBouncedRecipients: (emailAccount: string, daysBack?: number, scanDeleted?: boolean) => Promise<string[]>, readSentRecipientGroups: (emailAccount: string, daysBack?: number, limit?: number) => Promise<import("./types").SentRecipientGroup[]>, listOutlookSignatures: () => Promise<string[]>, readOutlookSignatureHtml: (name: string) => Promise<string>, readTemplateEmails: (emailAccount: string, folderName?: string, limit?: number, includeBody?: boolean, subject?: string) => Promise<import("./types").TemplateFolderResult>, saveTemplateEmail: (emailAccount: string, subject: string, htmlBody: string, folderName?: string) => Promise<import("./types").SaveTemplateResult>, editEmailTemplate: (label: string, currentHtml: string) => Promise<string>;

package/dist/OutlookService.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editEmailTemplate = exports.saveTemplateEmail = exports.readTemplateEmails = exports.readOutlookSignatureHtml = exports.listOutlookSignatures = exports.readSentRecipientGroups = exports.collectBouncedRecipients = exports.cleanUndeliverableEmails = exports.saveEmailAttachments = exports.saveEmailAttachmentDetailed = exports.saveEmailAttachment = exports.purgeDeletedItems = exports.deleteOutlookEmails = exports.deleteOutlookDrafts = exports.listOutlookDrafts = exports.moveOutlookEmails = exports.listInboxFolders = exports.openOutlookEmail = exports.readEmailBody = exports.readSelectedEmail = exports.searchInboxByFilter = exports.readInboxEmails = exports.sendAllDrafts = exports.replyOutlookEmail = exports.sendOutlookEmail = exports.getOutlookAccounts = void 0;
+exports.capabilities = capabilities;
+exports.supports = supports;
+exports.createOutlookBridge = createOutlookBridge;
+// Platform dispatcher for Outlook automation: Windows drives Outlook via
+// PowerShell + COM, macOS via AppleScript (see each implementation's index for
+// its platform notes — New Outlook for Mac supports composing but not mailbox
+// reading). Other platforms report no capabilities and every call rejects.
+//
+// Both implementations are pinned to `OutlookBridge` here rather than being
+// destructured straight off the module namespaces. That is the difference
+// between a consumer seeing `Promise<CleanUndeliverableResult>` and seeing
+// `Promise<CleanUndeliverableResult | { matched: unknown[] }>` — a union of
+// whatever the two platforms happened to declare, which is what this used to
+// publish.
+const windowsBridge = __importStar(require("./windows"));
+const macBridge = __importStar(require("./mac"));
+const runtime_1 = require("./runtime");
+const errors_1 = require("./errors");
+/** Every operation name, taken from the Windows bridge — the complete one. */
+const ALL_CAPABILITIES = Object.keys(windowsBridge.bridge);
+/**
+ * The backend for an OS with no Outlook automation at all.
+ *
+ * A third implementation rather than a fallback to the PowerShell one: making
+ * Windows the default for Linux and everything else meant the dispatcher held a
+ * bridge whose capability map had to be second-guessed afterwards, and whose
+ * functions each had to remember to refuse. Answering "not here" is itself an
+ * implementation of the contract, so it is written as one, once.
+ */
+const unsupportedBridge = {
+    bridge: Object.fromEntries(ALL_CAPABILITIES.map(name => [
+        name,
+        () => Promise.reject(new errors_1.UnsupportedPlatformError(process.platform)),
+    ])),
+    capabilities: Object.freeze(Object.fromEntries(ALL_CAPABILITIES.map(name => [name, false]))),
+};
+// The platform decision, made once. Everything below reads `impl` and
+// `implCapabilities` without asking which OS this is.
+const { bridge: impl, capabilities: implCapabilities } = process.platform === 'win32' ? windowsBridge
+    : process.platform === 'darwin' ? macBridge
+        : unsupportedBridge;
+/** Which operations work on this machine. See `CapabilityMap`. */
+function capabilities() {
+    return implCapabilities;
+}
+/** Whether one operation works here — `capabilities()` for a single name. */
+function supports(operation) {
+    return implCapabilities[operation] === true;
+}
+/**
+ * Build a bridge whose every call runs with `config` in force.
+ *
+ * The wrapper is what makes per-instance settings work at all: the platform
+ * implementations read their config from a module-level accessor, so the config
+ * has to be established around the call rather than passed into it. `withConfig`
+ * puts it in an AsyncLocalStorage that the whole async subtree inherits, which is
+ * why two bridges with different timeouts can run concurrently without seeing
+ * each other's.
+ */
+function build(config) {
+    const instance = {
+        capabilities,
+        supports,
+        withOptions: (options) => build((0, runtime_1.mergeOptions)(config, options)),
+        options: Object.freeze({ ...config }),
+    };
+    const source = impl;
+    for (const name of ALL_CAPABILITIES) {
+        const fn = source[name];
+        instance[name] = (...args) => {
+            // Errors thrown synchronously (an argument check ahead of the first
+            // await) become rejections here, so a caller has one failure channel.
+            try {
+                return (0, runtime_1.withConfig)(config, () => fn(...args));
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        };
+    }
+    return instance;
+}
+/**
+ * A bridge with its own settings, isolated from `configure()` and from every
+ * other instance.
+ *
+ * ```ts
+ * const bridge = createOutlookBridge({ timeoutMs: 30_000 });
+ * if (bridge.supports('searchInboxByFilter')) {
+ *     await bridge.withOptions({ signal }).searchInboxByFilter(account, filter);
+ * }
+ * ```
+ *
+ * Options left out fall back to the process-wide values as they stand when this
+ * is called.
+ */
+function createOutlookBridge(options = {}) {
+    return build((0, runtime_1.mergeOptions)((0, runtime_1.getGlobalConfig)(), options));
+}
+exports.getOutlookAccounts = impl.getOutlookAccounts, exports.sendOutlookEmail = impl.sendOutlookEmail, exports.replyOutlookEmail = impl.replyOutlookEmail, exports.sendAllDrafts = impl.sendAllDrafts, exports.readInboxEmails = impl.readInboxEmails, exports.searchInboxByFilter = impl.searchInboxByFilter, exports.readSelectedEmail = impl.readSelectedEmail, exports.readEmailBody = impl.readEmailBody, exports.openOutlookEmail = impl.openOutlookEmail, exports.listInboxFolders = impl.listInboxFolders, exports.moveOutlookEmails = impl.moveOutlookEmails, exports.listOutlookDrafts = impl.listOutlookDrafts, exports.deleteOutlookDrafts = impl.deleteOutlookDrafts, exports.deleteOutlookEmails = impl.deleteOutlookEmails, exports.purgeDeletedItems = impl.purgeDeletedItems, exports.saveEmailAttachment = impl.saveEmailAttachment, exports.saveEmailAttachmentDetailed = impl.saveEmailAttachmentDetailed, exports.saveEmailAttachments = impl.saveEmailAttachments, exports.cleanUndeliverableEmails = impl.cleanUndeliverableEmails, exports.collectBouncedRecipients = impl.collectBouncedRecipients, exports.readSentRecipientGroups = impl.readSentRecipientGroups, exports.listOutlookSignatures = impl.listOutlookSignatures, exports.readOutlookSignatureHtml = impl.readOutlookSignatureHtml, exports.readTemplateEmails = impl.readTemplateEmails, exports.saveTemplateEmail = impl.saveTemplateEmail, exports.editEmailTemplate = impl.editEmailTemplate;
+//# sourceMappingURL=OutlookService.js.map

package/dist/OutlookService.js.map

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