surface-cli 0.1.1 → 0.2.0

package/dist/lib/stored-mail.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from "node:fs";
+function storedAttachments(db, messageRef) {
+    return 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),
+    }));
+}
+function storedMessage(record, attachments) {
+    const hasReadableCache = Boolean(record.body_cache_path && existsSync(record.body_cache_path));
+    return {
+        message_ref: record.message_ref,
+        envelope: {
+            from: record.from_name || record.from_email
+                ? {
+                    name: record.from_name ?? "",
+                    email: record.from_email ?? "",
+                }
+                : null,
+            to: JSON.parse(record.to_json),
+            cc: JSON.parse(record.cc_json),
+            sent_at: record.sent_at,
+            received_at: record.received_at,
+            unread: Boolean(record.unread),
+            ...(record.subject ? { subject: record.subject } : {}),
+        },
+        snippet: record.snippet,
+        body: {
+            text: hasReadableCache && record.body_cache_path ? readFileSync(record.body_cache_path, "utf8") : "",
+            truncated: Boolean(record.body_truncated),
+            cached: hasReadableCache && Boolean(record.body_cached),
+            cached_bytes: record.body_cached_bytes,
+        },
+        attachments,
+        ...(record.invite_json ? { invite: JSON.parse(record.invite_json) } : {}),
+    };
+}
+export function threadHasReadableCache(db, threadRef) {
+    const messages = db.listStoredMessagesForThread(threadRef);
+    return messages.length > 0 && messages.every((message) => Boolean(message.body_cache_path && existsSync(message.body_cache_path)));
+}
+export function loadStoredThread(db, account, threadRef) {
+    const thread = db.getStoredThread(threadRef);
+    if (!thread) {
+        return null;
+    }
+    return {
+        thread_ref: thread.thread_ref,
+        source: {
+            provider: account.provider,
+            transport: account.transport,
+        },
+        envelope: {
+            subject: thread.subject ?? "",
+            participants: JSON.parse(thread.participants_json),
+            mailbox: thread.mailbox ?? "inbox",
+            labels: JSON.parse(thread.labels_json),
+            received_at: thread.received_at,
+            message_count: thread.message_count,
+            unread_count: thread.unread_count,
+            has_attachments: Boolean(thread.has_attachments),
+        },
+        summary: db.findSummary(threadRef),
+        messages: db.listStoredMessagesForThread(threadRef).map((message) => storedMessage(message, storedAttachments(db, message.message_ref))),
+    };
+}
+//# sourceMappingURL=stored-mail.js.map

package/dist/lib/stored-mail.js.map

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

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 { 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",
@@ -654,6 +862,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) {
@@ -754,11 +1028,13 @@ export class GmailApiAdapter {
             : { 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 +1042,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 +1177,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 = {