surface-cli 0.1.1 → 0.3.0

package/dist/providers/outlook/adapter.js

@@ -3,13 +3,33 @@ import { join } from "node:path";
 import { SurfaceError } from "../../lib/errors.js";
 import { assertWriteAllowed, collectWriteRecipients } from "../../lib/write-safety.js";
 import { makeAttachmentId, makeMessageRef, makeThreadRef } from "../../refs.js";
-import { summarizeThread } from "../../summarizer.js";
+import { summarizeAndPersistThreads } from "../../summarizer.js";
+import { annotateBodyWithInlineAttachments } from "../shared/inline-attachments.js";
 import { launchOutlookSession, probeOutlookAuth, promptForOutlookLogin } from "./session.js";
-import { applySearchQuery, applyUnreadFilter, captureOutlookServiceSession, collectSearchConversationIds, collectUnreadConversationIds, fetchConversationBundle, waitForOutlookMailboxReady, } from "./extract.js";
+import { applySearchQuery, applyUnreadFilter, captureOutlookServiceSession, collectCurrentConversationIds, collectSearchConversationIds, collectUnreadConversationIds, fetchConversationBundle, waitForOutlookMailboxReady, } from "./extract.js";
 import { buildOutlookInvite, itemIdData, mailboxFromExchange, mailboxesFromExchange, messageIdentity, normalizeOutlookBody, } from "./normalize.js";
 function outlookProfileDir(context) {
     return join(context.accountPaths.authDir, "profile");
 }
+async function withManagedOutlookSession(context, browserSession, work) {
+    if (browserSession) {
+        return work(browserSession);
+    }
+    const profileDir = outlookProfileDir(context);
+    if (!existsSync(profileDir)) {
+        throw new SurfaceError("reauth_required", "Outlook profile directory is missing for this account.", {
+            account: null,
+        });
+    }
+    const session = await launchOutlookSession(profileDir, { headless: true });
+    try {
+        return await work(session);
+    }
+    finally {
+        await session.context.close();
+        session.cleanup?.();
+    }
+}
 function threadProviderKey(conversationId) {
     return `outlook-thread:${conversationId}`;
 }
@@ -51,6 +71,38 @@ function uniqueParticipants(messages) {
     }
     return participants;
 }
+function quoteOutlookSearchValue(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return '""';
+    }
+    return /[\s"]/u.test(normalized) ? `"${normalized.replace(/"/g, '""')}"` : normalized;
+}
+function buildOutlookSearchQuery(query) {
+    const parts = [];
+    if (query.text?.trim()) {
+        parts.push(query.text.trim());
+    }
+    if (query.from?.trim()) {
+        parts.push(`from:${quoteOutlookSearchValue(query.from)}`);
+    }
+    if (query.subject?.trim()) {
+        parts.push(`subject:${quoteOutlookSearchValue(query.subject)}`);
+    }
+    return parts.length > 0 ? parts.join(" AND ") : undefined;
+}
+function threadMatchesStructuredFilters(thread, query) {
+    if (query.mailbox?.trim() && thread.envelope.mailbox.trim().toLowerCase() !== query.mailbox.trim().toLowerCase()) {
+        return false;
+    }
+    if ((query.labels?.length ?? 0) > 0) {
+        const available = new Set(thread.envelope.labels.map((label) => label.trim().toLowerCase()));
+        if ((query.labels ?? []).some((label) => !available.has(label.trim().toLowerCase()))) {
+            return false;
+        }
+    }
+    return true;
+}
 function inferThreadRsvpStatus(messages) {
     let latest = null;
     for (const message of messages) {
@@ -105,7 +157,6 @@ function buildAttachments(entry, messageKey) {
 }
 function normalizeMessage(entry, conversationId) {
     const item = entry.item;
-    const body = normalizeOutlookBody(item);
     const invite = buildOutlookInvite(item);
     const from = mailboxFromExchange(item.From ?? null)
         ?? mailboxFromExchange(item.Sender ?? null);
@@ -118,6 +169,8 @@ function normalizeMessage(entry, conversationId) {
     const instanceKey = typeof item.InstanceKey === "string" ? item.InstanceKey : undefined;
     const key = messageProviderKey(entry, conversationId);
     const attachments = buildAttachments(entry, key);
+    const body = normalizeOutlookBody(item);
+    const bodyText = annotateBodyWithInlineAttachments(body.text, attachments);
     const envelope = {
         from,
         to,
@@ -139,12 +192,12 @@ function normalizeMessage(entry, conversationId) {
     return {
         message_ref: "",
         envelope,
-        snippet: typeof item.Preview === "string" ? item.Preview : body.text.slice(0, 240),
+        snippet: typeof item.Preview === "string" ? item.Preview : bodyText.slice(0, 240),
         body: {
-            text: body.text,
+            text: bodyText,
             truncated: false,
             cached: true,
-            cached_bytes: Buffer.byteLength(body.text, "utf8"),
+            cached_bytes: Buffer.byteLength(bodyText, "utf8"),
         },
         attachments,
         ...(invite.is_invite
@@ -269,6 +322,12 @@ function parseOutlookMessageLocator(locatorJson) {
         meeting_end: stringOrNull(locator.meeting_end),
     };
 }
+function parseOutlookThreadLocator(locatorJson) {
+    const locator = JSON.parse(locatorJson);
+    return {
+        conversation_id: typeof locator.conversation_id === "string" ? locator.conversation_id : "",
+    };
+}
 function parseOutlookAttachmentLocator(locatorJson) {
     const locator = JSON.parse(locatorJson);
     return {
@@ -447,9 +506,6 @@ async function persistThreads(account, context, threads) {
             if (threadInviteStatus) {
                 context.db.updateInviteStatusForThread(resolvedThreadRef, threadInviteStatus);
             }
-            if (thread.summary) {
-                context.db.upsertSummary(resolvedThreadRef, thread.summary);
-            }
             persistedThreads.push({
                 ...thread,
                 thread_ref: resolvedThreadRef,
@@ -459,36 +515,18 @@ async function persistThreads(account, context, threads) {
         return persistedThreads;
     });
 }
-async function maybeSummarizeThreads(threads, context) {
-    if (context.config.summarizerBackend === "none") {
-        return threads;
-    }
-    const summarized = [];
-    for (const thread of threads) {
-        const summary = await summarizeThread(thread, context.config);
-        summarized.push({
-            ...thread,
-            summary,
-        });
-    }
-    return summarized;
+async function refreshOutlookConversationWithSession(account, conversationId, context, browserSession) {
+    const capturedSession = await captureOutlookServiceSession(browserSession.context, browserSession.page, {
+        timeoutMs: context.config.providerTimeoutMs,
+    });
+    const bundle = await fetchConversationBundle(browserSession.context.request, capturedSession, conversationId);
+    const persisted = await persistThreads(account, context, [normalizeThread(bundle)]);
+    await summarizeAndPersistThreads(persisted, context.config, context.db, context.db.getAccountIdentity(account));
 }
 async function refreshOutlookConversation(account, conversationId, context) {
-    const profileDir = outlookProfileDir(context);
-    const session = await launchOutlookSession(profileDir, { headless: true });
-    try {
-        const capturedSession = await captureOutlookServiceSession(session.context, session.page, {
-            timeoutMs: context.config.providerTimeoutMs,
-        });
-        const bundle = await fetchConversationBundle(session.context.request, capturedSession, conversationId);
-        await persistThreads(account, context, [normalizeThread(bundle)]);
-    }
-    finally {
-        await session.context.close();
-        session.cleanup?.();
-    }
+    await withManagedOutlookSession(context, undefined, (session) => refreshOutlookConversationWithSession(account, conversationId, context, session));
 }
-async function refreshStoredMessage(account, messageRef, context) {
+async function refreshStoredMessageWithSession(account, messageRef, context, browserSession) {
     const locatorRow = context.db.findProviderLocator("message", messageRef);
     if (!locatorRow) {
         throw new SurfaceError("cache_miss", `No provider locator exists for message '${messageRef}'.`, {
@@ -503,7 +541,7 @@ async function refreshStoredMessage(account, messageRef, context) {
             messageRef,
         });
     }
-    await refreshOutlookConversation(account, locator.conversation_id, context);
+    await refreshOutlookConversationWithSession(account, locator.conversation_id, context, browserSession);
     const refreshed = context.db.getStoredMessage(messageRef);
     if (!refreshed) {
         throw new SurfaceError("not_found", `Message '${messageRef}' could not be refreshed from Outlook.`, {
@@ -513,6 +551,9 @@ async function refreshStoredMessage(account, messageRef, context) {
     }
     return refreshed;
 }
+async function refreshStoredMessage(account, messageRef, context) {
+    return withManagedOutlookSession(context, undefined, (session) => refreshStoredMessageWithSession(account, messageRef, context, session));
+}
 async function resolveRsvpLocator(account, messageRef, context) {
     let stored = context.db.getStoredMessage(messageRef);
     if (!stored) {
@@ -1015,6 +1056,35 @@ function buildReadEnvelope(account, messageRef, threadRef, parsed, attachments,
         },
     };
 }
+async function fetchOutlookThreadsWithSession(account, context, browserSession, options) {
+    const { context: playwrightContext, page } = browserSession;
+    const capturedSession = await captureOutlookServiceSession(playwrightContext, page, {
+        timeoutMs: context.config.providerTimeoutMs,
+    });
+    let conversationIds;
+    if (options.kind === "fetch-unread") {
+        await applyUnreadFilter(page);
+        conversationIds = await collectUnreadConversationIds(page, options.fetchLimit ?? options.limit);
+    }
+    else if (options.kind === "browse-current-folder") {
+        conversationIds = await collectCurrentConversationIds(page, options.fetchLimit ?? options.limit);
+    }
+    else {
+        await applySearchQuery(page, options.queryText ?? "");
+        conversationIds = await collectSearchConversationIds(page, options.fetchLimit ?? options.limit);
+    }
+    const bundles = [];
+    for (const conversationId of conversationIds) {
+        bundles.push(await fetchConversationBundle(playwrightContext.request, capturedSession, conversationId));
+    }
+    const normalized = bundles.map((bundle) => normalizeThread(bundle));
+    const filtered = options.postFilter ? normalized.filter(options.postFilter) : normalized;
+    const limited = filtered.slice(0, options.limit);
+    const persisted = await persistThreads(account, context, limited);
+    return options.summarize === false
+        ? persisted
+        : await summarizeAndPersistThreads(persisted, context.config, context.db, context.db.getAccountIdentity(account));
+}
 async function fetchOutlookThreads(account, context, options) {
     const profileDir = outlookProfileDir(context);
     if (!existsSync(profileDir)) {
@@ -1022,33 +1092,81 @@ async function fetchOutlookThreads(account, context, options) {
             account: account.name,
         });
     }
-    const session = await launchOutlookSession(profileDir, { headless: true });
-    try {
-        const { context: browserContext, page } = session;
-        const capturedSession = await captureOutlookServiceSession(browserContext, page, {
-            timeoutMs: context.config.providerTimeoutMs,
+    return withManagedOutlookSession(context, undefined, (session) => fetchOutlookThreadsWithSession(account, context, session, options));
+}
+export async function searchOutlookWithSession(account, query, context, browserSession) {
+    const queryText = buildOutlookSearchQuery(query);
+    const normalizedLabels = new Set((query.labels ?? []).map((label) => label.trim().toLowerCase()).filter(Boolean));
+    const postFilter = (thread) => threadMatchesStructuredFilters(thread, query);
+    if (!queryText && normalizedLabels.has("unread")) {
+        const threads = await withManagedOutlookSession(context, browserSession, (session) => fetchOutlookThreadsWithSession(account, context, session, {
+            kind: "fetch-unread",
+            limit: query.limit,
+            fetchLimit: Math.min(Math.max(query.limit * 3, query.limit), 100),
+            postFilter,
+        }));
+        return threads.slice(0, query.limit);
+    }
+    const threads = await withManagedOutlookSession(context, browserSession, (session) => fetchOutlookThreadsWithSession(account, context, session, {
+        kind: queryText ? "search" : "browse-current-folder",
+        ...(queryText ? { queryText } : {}),
+        limit: query.limit,
+        fetchLimit: Math.min(Math.max(query.limit * 3, query.limit), 100),
+        postFilter,
+    }));
+    return threads.slice(0, query.limit);
+}
+export async function fetchUnreadOutlookWithSession(account, query, context, browserSession) {
+    return withManagedOutlookSession(context, browserSession, (session) => fetchOutlookThreadsWithSession(account, context, session, {
+        kind: "fetch-unread",
+        limit: query.limit,
+    }));
+}
+export async function refreshOutlookThreadWithSession(account, threadRef, context, browserSession) {
+    const locatorRow = context.db.findProviderLocator("thread", threadRef);
+    if (!locatorRow) {
+        throw new SurfaceError("cache_miss", `No provider locator exists for thread '${threadRef}'.`, {
+            account: account.name,
+            threadRef,
         });
-        let conversationIds;
-        if (options.kind === "fetch-unread") {
-            await applyUnreadFilter(page);
-            conversationIds = await collectUnreadConversationIds(page, options.limit);
-        }
-        else {
-            await applySearchQuery(page, options.queryText ?? "");
-            conversationIds = await collectSearchConversationIds(page, options.limit);
-        }
-        const bundles = [];
-        for (const conversationId of conversationIds) {
-            bundles.push(await fetchConversationBundle(browserContext.request, capturedSession, conversationId));
-        }
-        const normalized = bundles.map((bundle) => normalizeThread(bundle));
-        const summarized = options.summarize === false ? normalized : await maybeSummarizeThreads(normalized, context);
-        return await persistThreads(account, context, summarized);
     }
-    finally {
-        await session.context.close();
-        session.cleanup?.();
+    const locator = parseOutlookThreadLocator(locatorRow.locator_json);
+    if (!locator.conversation_id) {
+        throw new SurfaceError("transport_error", `Thread '${threadRef}' is missing an Outlook conversation id.`, {
+            account: account.name,
+            threadRef,
+        });
+    }
+    await withManagedOutlookSession(context, browserSession, (session) => refreshOutlookConversationWithSession(account, locator.conversation_id, context, session));
+}
+export async function readOutlookMessageWithSession(account, messageRef, refresh, context, browserSession) {
+    const stored = context.db.getStoredMessage(messageRef);
+    if (!stored) {
+        throw new SurfaceError("not_found", `Message '${messageRef}' was not found.`, {
+            account: account.name,
+            messageRef,
+        });
     }
+    const attachments = context.db.listAttachmentsForMessage(messageRef).map((attachment) => ({
+        attachment_id: attachment.attachment_id,
+        filename: attachment.filename,
+        mime_type: attachment.mime_type,
+        size_bytes: attachment.size_bytes,
+        inline: Boolean(attachment.inline),
+    }));
+    const hasReadableCache = Boolean(stored.body_cache_path && existsSync(stored.body_cache_path));
+    if (!refresh && hasReadableCache) {
+        return buildReadEnvelope(account, messageRef, stored.thread_ref, parseStoredMessage(stored), attachments, "hit");
+    }
+    const refreshed = await withManagedOutlookSession(context, browserSession, (session) => refreshStoredMessageWithSession(account, messageRef, context, session));
+    const refreshedAttachments = context.db.listAttachmentsForMessage(messageRef).map((attachment) => ({
+        attachment_id: attachment.attachment_id,
+        filename: attachment.filename,
+        mime_type: attachment.mime_type,
+        size_bytes: attachment.size_bytes,
+        inline: Boolean(attachment.inline),
+    }));
+    return buildReadEnvelope(account, messageRef, refreshed.thread_ref, parseStoredMessage(refreshed), refreshedAttachments, "refreshed");
 }
 async function mutateOutlookReadState(account, messageRefs, unread, context) {
     if (messageRefs.length === 0) {
@@ -1133,46 +1251,16 @@ export class OutlookWebPlaywrightAdapter {
         }
     }
     async search(account, query, context) {
-        return fetchOutlookThreads(account, context, {
-            kind: "search",
-            queryText: query.text,
-            limit: query.limit,
-        });
+        return searchOutlookWithSession(account, query, context);
     }
     async fetchUnread(account, query, context) {
-        return fetchOutlookThreads(account, context, {
-            kind: "fetch-unread",
-            limit: query.limit,
-        });
+        return fetchUnreadOutlookWithSession(account, query, context);
+    }
+    async refreshThread(account, threadRef, context) {
+        await refreshOutlookThreadWithSession(account, threadRef, context);
     }
     async readMessage(account, messageRef, refresh, context) {
-        const stored = context.db.getStoredMessage(messageRef);
-        if (!stored) {
-            throw new SurfaceError("not_found", `Message '${messageRef}' was not found.`, {
-                account: account.name,
-                messageRef,
-            });
-        }
-        const attachments = context.db.listAttachmentsForMessage(messageRef).map((attachment) => ({
-            attachment_id: attachment.attachment_id,
-            filename: attachment.filename,
-            mime_type: attachment.mime_type,
-            size_bytes: attachment.size_bytes,
-            inline: Boolean(attachment.inline),
-        }));
-        const hasReadableCache = Boolean(stored.body_cache_path && existsSync(stored.body_cache_path));
-        if (!refresh && hasReadableCache) {
-            return buildReadEnvelope(account, messageRef, stored.thread_ref, parseStoredMessage(stored), attachments, "hit");
-        }
-        const refreshed = await refreshStoredMessage(account, messageRef, context);
-        const refreshedAttachments = context.db.listAttachmentsForMessage(messageRef).map((attachment) => ({
-            attachment_id: attachment.attachment_id,
-            filename: attachment.filename,
-            mime_type: attachment.mime_type,
-            size_bytes: attachment.size_bytes,
-            inline: Boolean(attachment.inline),
-        }));
-        return buildReadEnvelope(account, messageRef, refreshed.thread_ref, parseStoredMessage(refreshed), refreshedAttachments, "refreshed");
+        return readOutlookMessageWithSession(account, messageRef, refresh, context);
     }
     async listAttachments(account, messageRef, context) {
         const message = context.db.findMessageByRef(messageRef);