ofw-mcp 2.9.2 → 2.10.0

package/dist/tools/_shared.js

@@ -71,6 +71,31 @@ export function mapRecipients(items) {
 export function hasRealView(recipients) {
     return recipients.some((r) => r.viewedAt !== null && !r.viewedAt.startsWith('1970-01-01'));
 }
+/** The reply target OFW actually reports, whichever field it chose to put it in. */
+export function threadedReplyTo(detail) {
+    return detail.replyToId ?? detail.inReplyTo ?? null;
+}
+/** True when the payload positively reports the message as threaded. */
+export function reportsThreaded(detail) {
+    return threadedReplyTo(detail) !== null || detail.showContext === true;
+}
+/**
+ * True when the payload POSITIVELY reports the message as unthreaded — the
+ * evidence bar a "reply linkage was dropped" warning must clear.
+ *
+ * Only `inReplyTo` and `showContext` count as evidence, because those are the
+ * fields OFW actually signals threading with. A present-but-null `replyToId`
+ * is NOT evidence: OFW routinely emits `replyToId: null` on items that ARE
+ * threaded (their linkage lives in `inReplyTo`), so treating it as a
+ * disconfirmation manufactures a false UNTHREADED warning on exactly OFW's
+ * normal shape. Total absence of all three fields is "not echoed", never
+ * "dropped".
+ */
+export function reportsUnthreaded(detail) {
+    if (reportsThreaded(detail))
+        return false;
+    return detail.inReplyTo !== undefined || detail.showContext !== undefined;
+}
 // True when the once-scraped list flags themselves say the message is read.
 // `showNeverViewed === false` is OFW's reliable "has been viewed" signal (per
 // CLAUDE.md); `read === true` is the inbox list's own flag. Both are only ever

package/dist/tools/draft-freshness.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { parseLenient } from '@chrischall/mcp-utils';
-import { ApiRecipientSchema, mapRecipients } from './_shared.js';
+import { ApiRecipientSchema, mapRecipients, threadedReplyTo } from './_shared.js';
 /** Thrown when the freshness check itself could not be completed. */
 export class DraftFreshnessError extends Error {
 }
@@ -37,8 +37,18 @@ export function draftRevision(d) {
 const ServerDraftSchema = z.looseObject({
     subject: z.string().optional(),
     body: z.string().optional(),
+    // BOTH spellings of the threading echo (see ThreadingEcho in _shared.ts):
+    // OFW reports the reply target as `replyToId` on some payloads and as
+    // `inReplyTo` on others. The snapshot derives one value from whichever is
+    // present, so the revision hashed here matches the one ofw_save_draft
+    // computed from the same server state — a one-sided read produced revisions
+    // that disagreed about the same draft.
     replyToId: z.number().nullable().optional(),
+    inReplyTo: z.number().nullable().optional(),
     recipients: z.array(ApiRecipientSchema).optional(),
+    // Attachment fileIds — read so send-by-draft carries the draft's
+    // attachments onto the sent message (see DraftContent.files).
+    files: z.array(z.number()).optional(),
     // Read for the LIFECYCLE answer (see tools/lifecycle.ts): which folder OFW
     // itself says this id lives in right now. `existsOnServer` alone cannot
     // distinguish "still a draft" from "was sent" — a sent draft still exists.
@@ -96,8 +106,9 @@ export async function fetchMessageSnapshot(client, id) {
         content: {
             subject: detail.subject ?? '',
             body: detail.body ?? '',
-            replyToId: detail.replyToId ?? null,
+            replyToId: threadedReplyTo(detail),
             recipients: mapRecipients(detail.recipients),
+            ...(detail.files !== undefined ? { files: detail.files } : {}),
         },
         folderId: detail.folder?.id === undefined ? null : String(detail.folder.id),
         folderName: detail.folder?.name ?? null,

package/dist/tools/lifecycle.js

@@ -61,25 +61,51 @@ export async function ensureFolderIdMap(client, store) {
         return { map: cached, requests: 1 };
     }
 }
+/**
+ * OFW's own display names for the three system folders, as observed on live
+ * detail payloads (`folder.name`). Keys are lower-cased for the comparison —
+ * this is a fixed vocabulary OFW controls, not user content, so a
+ * case-insensitive match is a normalization, not a guess. A Map, not a plain
+ * object: an object lookup reaches `Object.prototype`, so a folder named
+ * "constructor" would come back as a function and silently vanish from the
+ * JSON payload instead of classifying as `unknown`.
+ */
+const STATE_BY_FOLDER_NAME = new Map([
+    ['drafts', 'draft'],
+    ['sent', 'sent'],
+    ['sent messages', 'sent'],
+    ['inbox', 'received'],
+]);
 /**
  * Map a live snapshot to a lifecycle state. Pure — the request already happened.
  *
- * A null snapshot means OFW returned 404 / an empty body, i.e. `deleted`. An
- * unmappable folder is `unknown` rather than being guessed at: guessing here is
- * exactly how "still a draft" gets asserted about something that was sent.
+ * A null snapshot means OFW returned 404 / an empty body, i.e. `deleted`. The
+ * folder ID (matched against the persisted system-folder map) is the primary
+ * signal; when the id is unreported or unmapped, the folder NAME OFW itself put
+ * on the payload is a fallback with exactly the same authority — a snapshot
+ * reporting `folder.name: "Drafts"` answered the question, and declaring it
+ * `unknown` was a refusal to read the answer (observed live: every draft probe
+ * came back "unknown" while echoing the name "Drafts"). Only a folder that is
+ * unmappable by BOTH id and name is `unknown`: guessing beyond that is exactly
+ * how "still a draft" gets asserted about something that was sent.
  */
 export function classifyState(snapshot, map) {
     if (snapshot === null)
         return 'deleted';
-    const { folderId } = snapshot;
-    if (folderId === null)
-        return 'unknown';
-    if (map.drafts !== null && folderId === map.drafts)
-        return 'draft';
-    if (map.sent !== null && folderId === map.sent)
-        return 'sent';
-    if (map.inbox !== null && folderId === map.inbox)
-        return 'received';
+    const { folderId, folderName } = snapshot;
+    if (folderId !== null) {
+        if (map.drafts !== null && folderId === map.drafts)
+            return 'draft';
+        if (map.sent !== null && folderId === map.sent)
+            return 'sent';
+        if (map.inbox !== null && folderId === map.inbox)
+            return 'received';
+    }
+    if (folderName !== null) {
+        const byName = STATE_BY_FOLDER_NAME.get(folderName.trim().toLowerCase());
+        if (byName !== undefined)
+            return byName;
+    }
     return 'unknown';
 }
 /**