surface-cli 0.1.1 → 0.3.0

package/dist/providers/gmail/adapter.js

@@ -1,11 +1,12 @@
 import { Buffer } from "node:buffer";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { SurfaceError, notImplemented } from "../../lib/errors.js";
+import { SurfaceError } from "../../lib/errors.js";
 import { assertWriteAllowed } from "../../lib/write-safety.js";
 import { makeAttachmentId, makeMessageRef, makeThreadRef } from "../../refs.js";
-import { summarizeThread } from "../../summarizer.js";
-import { createGmailDraft, downloadGmailAttachmentBytes, getGmailThread, listGmailThreads, modifyGmailMessage, modifyGmailThread, sendGmailRawMessage, } from "./api.js";
+import { summarizeAndPersistThreads } from "../../summarizer.js";
+import { annotateBodyWithInlineAttachments } from "../shared/inline-attachments.js";
+import { createGmailDraft, downloadGmailAttachmentBytes, getGoogleCalendarEvent, getGmailThread, listGmailThreads, listGoogleCalendarEventsByIcalUid, modifyGmailMessage, modifyGmailThread, patchGoogleCalendarEvent, sendGmailRawMessage, } from "./api.js";
 import { clearGmailAuthState, gmailAuthStatus, runGmailLogin } from "./oauth.js";
 import { decodeBase64UrlBytes, decodePartData, headerDateToIso, headerIndex, internalDateToIso, isCalendarPart, iterParts, normalizeGmailBody, parseCalendarInvite, parseMailbox, parseMailboxes, } from "./normalize.js";
 function sourceInfo(account) {
@@ -76,6 +77,88 @@ function gmailMailbox(labels) {
     }
     return "archive";
 }
+function quoteGmailSearchValue(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return '""';
+    }
+    return /[\s"]/u.test(normalized) ? `"${normalized.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : normalized;
+}
+function gmailMailboxSearchOperator(mailbox) {
+    const normalized = mailbox.trim().toLowerCase();
+    switch (normalized) {
+        case "drafts":
+            return "in:drafts";
+        case "sent":
+            return "in:sent";
+        case "trash":
+            return "in:trash";
+        case "spam":
+            return "in:spam";
+        case "inbox":
+            return "in:inbox";
+        case "archive":
+            return "in:archive";
+        default:
+            return `in:${quoteGmailSearchValue(normalized)}`;
+    }
+}
+function gmailLabelSearchOperator(label) {
+    const normalized = normalizeLabel(label);
+    switch (normalized) {
+        case "unread":
+            return "is:unread";
+        case "read":
+            return "is:read";
+        case "starred":
+            return "is:starred";
+        case "important":
+            return "label:important";
+        case "inbox":
+        case "sent":
+        case "drafts":
+        case "trash":
+        case "spam":
+        case "archive":
+            return gmailMailboxSearchOperator(normalized);
+        default:
+            return `label:${quoteGmailSearchValue(normalized)}`;
+    }
+}
+function buildGmailSearchQuery(query) {
+    const parts = [];
+    if (query.text?.trim()) {
+        parts.push(query.text.trim());
+    }
+    if (query.from?.trim()) {
+        parts.push(`from:${quoteGmailSearchValue(query.from)}`);
+    }
+    if (query.subject?.trim()) {
+        parts.push(`subject:${quoteGmailSearchValue(query.subject)}`);
+    }
+    if (query.mailbox?.trim()) {
+        parts.push(gmailMailboxSearchOperator(query.mailbox));
+    }
+    for (const label of query.labels ?? []) {
+        if (!label.trim()) {
+            continue;
+        }
+        parts.push(gmailLabelSearchOperator(label));
+    }
+    return parts.length > 0 ? parts.join(" ").trim() : 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 partSizeBytes(part) {
     if (typeof part.body?.size === "number") {
         return part.body.size;
@@ -152,6 +235,126 @@ function mapCalendarPartstat(value) {
             return null;
     }
 }
+function mapGoogleCalendarResponseStatus(value) {
+    const normalized = (value ?? "").trim().toLowerCase();
+    switch (normalized) {
+        case "accepted":
+            return "accept";
+        case "declined":
+            return "decline";
+        case "tentative":
+            return "tentative";
+        case "needsaction":
+            return "needs_response";
+        default:
+            return null;
+    }
+}
+function googleCalendarResponseStatusForRsvp(response) {
+    switch (response) {
+        case "accept":
+            return "accepted";
+        case "decline":
+            return "declined";
+        case "tentative":
+            return "tentative";
+    }
+}
+function googleCalendarEventStart(event) {
+    return event.start?.dateTime ?? event.start?.date ?? null;
+}
+function normalizeComparableDatePrefix(value) {
+    if (!value) {
+        return null;
+    }
+    const match = value.match(/^(\d{4}-\d{2}-\d{2})/);
+    return match?.[1] ?? null;
+}
+function chooseGoogleCalendarEvent(events, meetingStart) {
+    if (events.length === 0) {
+        return null;
+    }
+    const targetDate = normalizeComparableDatePrefix(meetingStart);
+    if (targetDate) {
+        const match = events.find((event) => normalizeComparableDatePrefix(googleCalendarEventStart(event)) === targetDate);
+        if (match) {
+            return match;
+        }
+    }
+    return events[0] ?? null;
+}
+function pickCalendarAttendee(event, attendeeEmail, fallbackEmail) {
+    const normalizedTarget = (attendeeEmail ?? fallbackEmail).trim().toLowerCase();
+    const normalizedFallback = fallbackEmail.trim().toLowerCase();
+    const attendees = event.attendees ?? [];
+    const chosen = attendees.find((attendee) => attendee.self === true)
+        ?? attendees.find((attendee) => (attendee.email ?? "").trim().toLowerCase() === normalizedTarget)
+        ?? attendees.find((attendee) => (attendee.email ?? "").trim().toLowerCase() === normalizedFallback);
+    if (!chosen?.email) {
+        return normalizedTarget
+            ? { email: normalizedTarget, response_status: null }
+            : null;
+    }
+    return {
+        email: chosen.email,
+        response_status: mapGoogleCalendarResponseStatus(chosen.responseStatus),
+    };
+}
+async function hydrateGmailInviteMetadataFromCalendar(account, context, metadata) {
+    if (!metadata.calendar_uid) {
+        return metadata;
+    }
+    try {
+        const events = await listGoogleCalendarEventsByIcalUid(account, context, "primary", metadata.calendar_uid);
+        const event = chooseGoogleCalendarEvent(events, metadata.meeting_start);
+        if (!event) {
+            return metadata;
+        }
+        const attendee = pickCalendarAttendee(event, metadata.attendee_email, account.email);
+        return {
+            ...metadata,
+            attendee_email: attendee?.email ?? metadata.attendee_email,
+            invite: {
+                ...metadata.invite,
+                rsvp_supported: true,
+                response_status: attendee?.response_status ?? metadata.invite.response_status,
+                available_rsvp_responses: ["accept", "decline", "tentative"],
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof SurfaceError && (error.code === "reauth_required" || error.code === "transport_error")) {
+            return metadata;
+        }
+        throw error;
+    }
+}
+async function extractGmailInviteMetadata(account, context, message, participants) {
+    const calendarText = await extractCalendarText(account, context, message);
+    if (!calendarText) {
+        return null;
+    }
+    const parsedInvite = parseCalendarInvite(calendarText, {
+        mailboxEmail: account.email,
+        recipientEmails: [...participants.to, ...participants.cc].map((mailbox) => mailbox.email),
+    });
+    const meeting = parsedInvite.meeting;
+    if (!meeting) {
+        return null;
+    }
+    const metadata = {
+        invite: {
+            is_invite: true,
+            rsvp_supported: Boolean(meeting.uid),
+            response_status: mapCalendarPartstat(meeting.response_type),
+            available_rsvp_responses: meeting.uid ? ["accept", "decline", "tentative"] : [],
+        },
+        calendar_uid: meeting.uid ?? null,
+        attendee_email: meeting.attendee?.email ?? null,
+        meeting_start: meeting.start ?? null,
+    };
+    return hydrateGmailInviteMetadataFromCalendar(account, context, metadata);
+}
 async function normalizeGmailMessage(account, context, message) {
     const indexedHeaders = headerIndex(message.payload?.headers);
     const subject = indexedHeaders.subject ?? "";
@@ -163,22 +366,9 @@ async function normalizeGmailMessage(account, context, message) {
     const unread = (message.labelIds ?? []).includes("UNREAD");
     const body = normalizeGmailBody(message.payload, message.snippet ?? "");
     const attachments = extractAttachmentRecords(message);
-    let invite;
-    const calendarText = await extractCalendarText(account, context, message);
-    if (calendarText) {
-        const parsedInvite = parseCalendarInvite(calendarText, {
-            mailboxEmail: account.email,
-            recipientEmails: [...to, ...cc].map((mailbox) => mailbox.email),
-        });
-        if (parsedInvite.meeting) {
-            invite = {
-                is_invite: true,
-                rsvp_supported: false,
-                response_status: mapCalendarPartstat(parsedInvite.meeting.response_type),
-                available_rsvp_responses: [],
-            };
-        }
-    }
+    const bodyText = annotateBodyWithInlineAttachments(body.text, attachments);
+    const inviteMetadata = await extractGmailInviteMetadata(account, context, message, { to, cc });
+    const invite = inviteMetadata?.invite;
     return {
         message_ref: "",
         envelope: {
@@ -190,12 +380,12 @@ async function normalizeGmailMessage(account, context, message) {
             unread,
             ...(subject ? { subject } : {}),
         },
-        snippet: message.snippet ?? body.text.slice(0, 240),
+        snippet: message.snippet ?? 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 ? { invite } : {}),
@@ -208,6 +398,9 @@ async function normalizeGmailMessage(account, context, message) {
             locator: {
                 thread_id: message.threadId ?? null,
                 message_id: message.id ?? null,
+                calendar_uid: inviteMetadata?.calendar_uid ?? null,
+                attendee_email: inviteMetadata?.attendee_email ?? null,
+                meeting_start: inviteMetadata?.meeting_start ?? null,
             },
         },
     };
@@ -368,6 +561,9 @@ function parseMessageLocator(locatorJson) {
     return {
         thread_id: typeof parsed.thread_id === "string" && parsed.thread_id ? parsed.thread_id : null,
         message_id: typeof parsed.message_id === "string" && parsed.message_id ? parsed.message_id : null,
+        calendar_uid: typeof parsed.calendar_uid === "string" && parsed.calendar_uid ? parsed.calendar_uid : null,
+        attendee_email: typeof parsed.attendee_email === "string" && parsed.attendee_email ? parsed.attendee_email : null,
+        meeting_start: typeof parsed.meeting_start === "string" && parsed.meeting_start ? parsed.meeting_start : null,
     };
 }
 function latestStoredThreadMessage(threadRef, context) {
@@ -411,6 +607,18 @@ function buildMarkMessagesEnvelope(account, command, updated) {
         updated,
     };
 }
+function buildRsvpEnvelope(account, messageRef, threadRef, response, invite) {
+    return {
+        schema_version: "1",
+        command: "rsvp",
+        account: account.name,
+        message_ref: messageRef,
+        thread_ref: threadRef,
+        source: sourceInfo(account),
+        response,
+        invite: invite ?? null,
+    };
+}
 function buildReadEnvelope(account, messageRef, threadRef, parsed, attachments, cacheStatus) {
     return {
         schema_version: "1",
@@ -431,19 +639,6 @@ function buildReadEnvelope(account, messageRef, threadRef, parsed, attachments,
         },
     };
 }
-async function maybeSummarizeThreads(threads, context) {
-    if (context.config.summarizerBackend === "none") {
-        return threads;
-    }
-    const summarized = [];
-    for (const thread of threads) {
-        summarized.push({
-            ...thread,
-            summary: await summarizeThread(thread, context.config),
-        });
-    }
-    return summarized;
-}
 async function persistThreads(account, context, threads) {
     return context.db.transaction(() => {
         const persistedThreads = [];
@@ -557,9 +752,6 @@ async function persistThreads(account, context, threads) {
                 messageRefs.push(resolvedMessageRef);
             }
             context.db.replaceThreadMessages(resolvedThreadRef, messageRefs);
-            if (thread.summary) {
-                context.db.upsertSummary(resolvedThreadRef, thread.summary);
-            }
             persistedThreads.push({
                 ...thread,
                 thread_ref: resolvedThreadRef,
@@ -572,8 +764,8 @@ async function persistThreads(account, context, threads) {
 async function fetchAndPersistGmailThread(account, context, threadId) {
     const thread = await getGmailThread(account, context, threadId);
     const normalized = await normalizeGmailThread(account, context, thread);
-    const withSummary = (await maybeSummarizeThreads([normalized], context))[0];
-    await persistThreads(account, context, [withSummary]);
+    const persisted = await persistThreads(account, context, [normalized]);
+    await summarizeAndPersistThreads(persisted, context.config, context.db, context.db.getAccountIdentity(account));
 }
 async function refreshStoredMessage(account, messageRef, context) {
     const locatorRow = context.db.findProviderLocator("message", messageRef);
@@ -654,6 +846,72 @@ async function resolveGmailMessageContext(account, messageRef, context) {
         headers: headerIndex(message.payload?.headers),
     };
 }
+async function resolveGmailRsvpTarget(account, messageRef, context) {
+    const target = await resolveGmailMessageContext(account, messageRef, context);
+    const inviteMetadata = await extractGmailInviteMetadata(account, context, target.message, {
+        to: parseMailboxes(target.headers.to),
+        cc: parseMailboxes(target.headers.cc),
+    });
+    if (!inviteMetadata?.calendar_uid) {
+        throw new SurfaceError("unsupported", `Message '${messageRef}' is not a Gmail calendar invite with a resolvable UID.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    if (!inviteMetadata.invite.rsvp_supported) {
+        throw new SurfaceError("unsupported", `Message '${messageRef}' is not a Gmail invite Surface can RSVP to.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    const attendeeEmail = inviteMetadata.attendee_email?.trim().toLowerCase()
+        || account.email.trim().toLowerCase();
+    if (!attendeeEmail) {
+        throw new SurfaceError("unsupported", `Message '${messageRef}' does not expose an attendee email for RSVP.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    return {
+        stored: target.stored,
+        message: target.message,
+        threadRef: target.stored.thread_ref,
+        calendarUid: inviteMetadata.calendar_uid,
+        attendeeEmail,
+        meetingStart: inviteMetadata.meeting_start,
+        invite: inviteMetadata.invite,
+    };
+}
+async function performGmailRsvp(account, context, target, response) {
+    const events = await listGoogleCalendarEventsByIcalUid(account, context, "primary", target.calendarUid);
+    const event = chooseGoogleCalendarEvent(events, target.meetingStart);
+    if (!event?.id) {
+        throw new SurfaceError("not_found", `Google Calendar could not find an event matching invite UID '${target.calendarUid}'.`, { account: account.name });
+    }
+    const attendee = pickCalendarAttendee(event, target.attendeeEmail, account.email);
+    if (!attendee?.email) {
+        throw new SurfaceError("unsupported", `Google Calendar event '${event.id}' does not expose an attendee that Surface can RSVP as.`, { account: account.name });
+    }
+    const patched = await patchGoogleCalendarEvent(account, context, "primary", event.id, {
+        attendeesOmitted: true,
+        attendees: [
+            {
+                email: attendee.email,
+                responseStatus: googleCalendarResponseStatusForRsvp(response),
+            },
+        ],
+    });
+    const refreshed = patched.id
+        ? await getGoogleCalendarEvent(account, context, "primary", patched.id)
+        : patched;
+    const refreshedAttendee = pickCalendarAttendee(refreshed, attendee.email, account.email);
+    return {
+        is_invite: true,
+        rsvp_supported: true,
+        response_status: refreshedAttendee?.response_status ?? mapGoogleCalendarResponseStatus(googleCalendarResponseStatusForRsvp(response)),
+        available_rsvp_responses: ["accept", "decline", "tentative"],
+    };
+}
 async function refreshRefsFromGmailResponse(account, context, response) {
     const threadId = response.threadId ?? null;
     if (threadId) {
@@ -697,8 +955,8 @@ async function fetchGmailThreads(account, context, options) {
         .filter((threadId) => Boolean(threadId))
         .map((threadId) => getGmailThread(account, context, threadId)));
     const normalized = await Promise.all(hydrated.map((thread) => normalizeGmailThread(account, context, thread)));
-    const summarized = await maybeSummarizeThreads(normalized, context);
-    return persistThreads(account, context, summarized);
+    const persisted = await persistThreads(account, context, normalized);
+    return summarizeAndPersistThreads(persisted, context.config, context.db, context.db.getAccountIdentity(account));
 }
 async function sendOrDraftGmailMessage(account, context, payload) {
     if (payload.draft) {
@@ -725,13 +983,8 @@ export class GmailApiAdapter {
     transport = "gmail-api";
     async login(account, context) {
         const result = await runGmailLogin(account, context);
-        if (result.authenticatedEmail && result.authenticatedEmail !== account.email) {
-            context.db.upsertAccount({
-                name: account.name,
-                provider: account.provider,
-                transport: account.transport,
-                email: result.authenticatedEmail,
-            });
+        if (result.authenticatedEmail) {
+            context.db.updateAccountIdentityFromProvider(account, result.authenticatedEmail);
         }
         return {
             status: "authenticated",
@@ -749,16 +1002,21 @@ export class GmailApiAdapter {
     }
     async authStatus(account, context) {
         const status = await gmailAuthStatus(account, context);
+        if (status.authenticatedEmail) {
+            context.db.updateAccountIdentityFromProvider(account, status.authenticatedEmail);
+        }
         return status.authenticated
             ? { status: "authenticated", detail: status.detail }
             : { status: "unauthenticated", detail: status.detail };
     }
     async search(account, query, context) {
-        return fetchGmailThreads(account, context, {
+        const queryText = buildGmailSearchQuery(query);
+        const threads = await fetchGmailThreads(account, context, {
             kind: "search",
-            queryText: query.text,
+            ...(queryText ? { queryText } : {}),
             limit: query.limit,
         });
+        return threads.filter((thread) => threadMatchesStructuredFilters(thread, query)).slice(0, query.limit);
     }
     async fetchUnread(account, query, context) {
         return fetchGmailThreads(account, context, {
@@ -766,6 +1024,23 @@ export class GmailApiAdapter {
             limit: query.limit,
         });
     }
+    async refreshThread(account, threadRef, context) {
+        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,
+            });
+        }
+        const locator = JSON.parse(locatorRow.locator_json);
+        if (!locator.thread_id) {
+            throw new SurfaceError("transport_error", `Thread '${threadRef}' is missing a Gmail thread id.`, {
+                account: account.name,
+                threadRef,
+            });
+        }
+        await fetchAndPersistGmailThread(account, context, locator.thread_id);
+    }
     async readMessage(account, messageRef, refresh, context) {
         const stored = context.db.getStoredMessage(messageRef);
         if (!stored) {
@@ -884,8 +1159,16 @@ export class GmailApiAdapter {
             },
         };
     }
-    async rsvp(account, _messageRef, _response) {
-        notImplemented("Gmail RSVP is deferred pending explicit Google Calendar integration.", account.name);
+    async rsvp(account, messageRef, response, context) {
+        const target = await resolveGmailRsvpTarget(account, messageRef, context);
+        const invite = await performGmailRsvp(account, context, target, response);
+        context.db.updateInviteForThread(target.threadRef, {
+            is_invite: true,
+            rsvp_supported: invite.rsvp_supported,
+            response_status: invite.response_status,
+            available_rsvp_responses: invite.available_rsvp_responses,
+        });
+        return buildRsvpEnvelope(account, messageRef, target.threadRef, response, invite);
     }
     async sendMessage(account, input, context) {
         const recipients = {