surface-cli 0.1.0

package/dist/providers/gmail/adapter.js

@@ -0,0 +1,1102 @@
+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 { 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 { clearGmailAuthState, gmailAuthStatus, runGmailLogin } from "./oauth.js";
+import { decodeBase64UrlBytes, decodePartData, headerDateToIso, headerIndex, internalDateToIso, isCalendarPart, iterParts, normalizeGmailBody, parseCalendarInvite, parseMailbox, parseMailboxes, } from "./normalize.js";
+function sourceInfo(account) {
+    return {
+        provider: account.provider,
+        transport: account.transport,
+    };
+}
+function gmailThreadProviderKey(threadId) {
+    return `gmail-thread:${threadId}`;
+}
+function gmailMessageProviderKey(messageId) {
+    return `gmail-message:${messageId}`;
+}
+function gmailAttachmentProviderKey(messageId, attachment, index) {
+    const attachmentId = attachment.locator?.locator.attachment_id;
+    return typeof attachmentId === "string" && attachmentId
+        ? `gmail-attachment:${messageId}:${attachmentId}`
+        : `gmail-attachment:${messageId}:${attachment.filename}:${index}`;
+}
+function uniqueParticipants(messages) {
+    const seen = new Set();
+    const participants = [];
+    const push = (role, mailbox) => {
+        if (!mailbox || (!mailbox.email && !mailbox.name)) {
+            return;
+        }
+        const key = `${role}:${mailbox.email}:${mailbox.name}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        participants.push({
+            role,
+            name: mailbox.name,
+            email: mailbox.email,
+        });
+    };
+    for (const message of messages) {
+        push("from", message.from);
+        for (const mailbox of message.to) {
+            push("to", mailbox);
+        }
+        for (const mailbox of message.cc) {
+            push("cc", mailbox);
+        }
+    }
+    return participants;
+}
+function normalizeLabel(label) {
+    return label.trim().toLowerCase();
+}
+function gmailMailbox(labels) {
+    if (labels.includes("DRAFT")) {
+        return "drafts";
+    }
+    if (labels.includes("SENT")) {
+        return "sent";
+    }
+    if (labels.includes("TRASH")) {
+        return "trash";
+    }
+    if (labels.includes("SPAM")) {
+        return "spam";
+    }
+    if (labels.includes("INBOX")) {
+        return "inbox";
+    }
+    return "archive";
+}
+function partSizeBytes(part) {
+    if (typeof part.body?.size === "number") {
+        return part.body.size;
+    }
+    if (part.body?.data) {
+        return decodeBase64UrlBytes(part.body.data).byteLength;
+    }
+    return null;
+}
+function extractAttachmentRecords(message) {
+    const messageId = message.id ?? "";
+    const attachments = [];
+    let index = 0;
+    for (const part of iterParts(message.payload)) {
+        if (!(part.filename ?? "").trim()) {
+            continue;
+        }
+        const attachmentId = part.body?.attachmentId;
+        const inlineData = part.body?.data;
+        attachments.push({
+            attachment_id: "",
+            filename: part.filename ?? `attachment-${index + 1}`,
+            mime_type: part.mimeType ?? "application/octet-stream",
+            size_bytes: partSizeBytes(part),
+            inline: Boolean(part.headers && headerIndex(part.headers)["content-disposition"]?.toLowerCase().includes("inline")),
+            locator: {
+                kind: "attachment",
+                locator: {
+                    message_id: messageId,
+                    attachment_id: attachmentId ?? null,
+                    part_id: part.partId ?? null,
+                    inline_data: inlineData ?? null,
+                    filename: part.filename ?? null,
+                },
+            },
+        });
+        index += 1;
+    }
+    return attachments;
+}
+async function extractCalendarText(account, context, message) {
+    const messageId = message.id ?? "";
+    if (!messageId) {
+        return "";
+    }
+    for (const part of iterParts(message.payload)) {
+        if (!isCalendarPart(part)) {
+            continue;
+        }
+        if (part.body?.data) {
+            return decodePartData(part);
+        }
+        if (part.body?.attachmentId) {
+            const payload = await downloadGmailAttachmentBytes(account, context, messageId, part.body.attachmentId);
+            if (payload.data) {
+                return Buffer.from(decodeBase64UrlBytes(payload.data)).toString("utf8");
+            }
+        }
+    }
+    return "";
+}
+function mapCalendarPartstat(value) {
+    const normalized = typeof value === "string" ? value.toUpperCase() : "";
+    switch (normalized) {
+        case "ACCEPTED":
+            return "accept";
+        case "DECLINED":
+            return "decline";
+        case "TENTATIVE":
+            return "tentative";
+        case "NEEDS-ACTION":
+            return "needs_response";
+        default:
+            return null;
+    }
+}
+async function normalizeGmailMessage(account, context, message) {
+    const indexedHeaders = headerIndex(message.payload?.headers);
+    const subject = indexedHeaders.subject ?? "";
+    const from = parseMailbox(indexedHeaders.from);
+    const to = parseMailboxes(indexedHeaders.to);
+    const cc = parseMailboxes(indexedHeaders.cc);
+    const sentAt = headerDateToIso(indexedHeaders.date) ?? internalDateToIso(message.internalDate);
+    const receivedAt = internalDateToIso(message.internalDate) ?? headerDateToIso(indexedHeaders.date);
+    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: [],
+            };
+        }
+    }
+    return {
+        message_ref: "",
+        envelope: {
+            from,
+            to,
+            cc,
+            sent_at: sentAt,
+            received_at: receivedAt,
+            unread,
+            ...(subject ? { subject } : {}),
+        },
+        snippet: message.snippet ?? body.text.slice(0, 240),
+        body: {
+            text: body.text,
+            truncated: false,
+            cached: true,
+            cached_bytes: Buffer.byteLength(body.text, "utf8"),
+        },
+        attachments,
+        ...(invite ? { invite } : {}),
+        provider_ids: {
+            ...(message.id ? { message_id: message.id } : {}),
+            ...(indexedHeaders["message-id"] ? { internet_message_id: indexedHeaders["message-id"] } : {}),
+        },
+        locator: {
+            kind: "message",
+            locator: {
+                thread_id: message.threadId ?? null,
+                message_id: message.id ?? null,
+            },
+        },
+    };
+}
+async function normalizeGmailThread(account, context, thread) {
+    const normalizedMessages = await Promise.all((thread.messages ?? []).map((message) => normalizeGmailMessage(account, context, message)));
+    const messages = normalizedMessages
+        .slice()
+        .sort((left, right) => Date.parse(right.envelope.received_at ?? right.envelope.sent_at ?? "") - Date.parse(left.envelope.received_at ?? left.envelope.sent_at ?? ""));
+    const latestMessage = messages[0] ?? null;
+    const unreadCount = messages.filter((message) => message.envelope.unread).length;
+    const labels = [...new Set((thread.messages?.flatMap((message) => message.labelIds ?? []) ?? []).map(normalizeLabel))];
+    return {
+        thread_ref: "",
+        source: sourceInfo(account),
+        envelope: {
+            subject: latestMessage?.envelope.subject ?? "",
+            participants: uniqueParticipants(messages.map((message) => message.envelope)),
+            mailbox: gmailMailbox(thread.messages?.[0]?.labelIds ?? []),
+            labels,
+            received_at: latestMessage?.envelope.received_at ?? null,
+            message_count: messages.length,
+            unread_count: unreadCount,
+            has_attachments: messages.some((message) => message.attachments.length > 0),
+        },
+        summary: null,
+        messages,
+        provider_ids: {
+            ...(thread.id ? { thread_id: thread.id } : {}),
+        },
+        locator: {
+            kind: "thread",
+            locator: {
+                thread_id: thread.id ?? null,
+            },
+        },
+    };
+}
+function parseStoredMessage(record) {
+    const 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 } : {}),
+    };
+    return {
+        envelope,
+        body: {
+            text: record.body_cache_path && existsSync(record.body_cache_path) ? readFileSync(record.body_cache_path, "utf8") : "",
+            truncated: Boolean(record.body_truncated),
+            cached: Boolean(record.body_cached),
+            cached_bytes: record.body_cached_bytes,
+        },
+        invite: record.invite_json ? JSON.parse(record.invite_json) : undefined,
+    };
+}
+function participantFromEmail(email) {
+    return {
+        name: email,
+        email,
+    };
+}
+function recipientsFromInput(input) {
+    return {
+        to: input.to.map(participantFromEmail),
+        cc: input.cc.map(participantFromEmail),
+        bcc: input.bcc.map(participantFromEmail),
+    };
+}
+function normalizeEmailList(values) {
+    const deduped = new Set();
+    for (const value of values) {
+        const normalized = value?.trim();
+        if (!normalized) {
+            continue;
+        }
+        deduped.add(normalized);
+    }
+    return [...deduped];
+}
+function sanitizeHeaderValue(value) {
+    return value.replace(/\r?\n/g, " ").trim();
+}
+function prefixSubject(subject, prefix) {
+    const normalized = subject.trim();
+    if (!normalized) {
+        return `${prefix}:`;
+    }
+    const matcher = prefix === "Re" ? /^re:\s/i : /^(fwd|fw):\s/i;
+    return matcher.test(normalized) ? normalized : `${prefix}: ${normalized}`;
+}
+function quoteLines(text) {
+    return text
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => `> ${line}`)
+        .join("\n");
+}
+function buildReplyBody(inputBody, stored) {
+    const parsed = parseStoredMessage(stored);
+    const originalBody = parsed.body.text.trim();
+    const originalFrom = parsed.envelope.from?.email ?? parsed.envelope.from?.name ?? "unknown sender";
+    const originalDate = parsed.envelope.sent_at ?? parsed.envelope.received_at ?? "unknown time";
+    if (!originalBody) {
+        return inputBody;
+    }
+    return `${inputBody}\n\nOn ${originalDate}, ${originalFrom} wrote:\n${quoteLines(originalBody)}`;
+}
+function buildForwardBody(inputBody, stored) {
+    const parsed = parseStoredMessage(stored);
+    const originalBody = parsed.body.text.trim();
+    const lines = [
+        inputBody,
+        "",
+        "---------- Forwarded message ---------",
+        `From: ${parsed.envelope.from?.email ?? parsed.envelope.from?.name ?? ""}`,
+        `Date: ${parsed.envelope.sent_at ?? parsed.envelope.received_at ?? ""}`,
+        `Subject: ${parsed.envelope.subject ?? ""}`,
+        `To: ${parsed.envelope.to.map((mailbox) => mailbox.email).join(", ")}`,
+    ];
+    if (parsed.envelope.cc.length > 0) {
+        lines.push(`Cc: ${parsed.envelope.cc.map((mailbox) => mailbox.email).join(", ")}`);
+    }
+    lines.push("", originalBody);
+    return lines.join("\n").trim();
+}
+function encodeMimeBase64Url(mime) {
+    return Buffer.from(mime, "utf8").toString("base64url");
+}
+function buildRawMimeMessage(input) {
+    const lines = [
+        `From: ${sanitizeHeaderValue(input.from)}`,
+        ...(input.to.length > 0 ? [`To: ${input.to.map(sanitizeHeaderValue).join(", ")}`] : []),
+        ...(input.cc.length > 0 ? [`Cc: ${input.cc.map(sanitizeHeaderValue).join(", ")}`] : []),
+        ...(input.bcc.length > 0 ? [`Bcc: ${input.bcc.map(sanitizeHeaderValue).join(", ")}`] : []),
+        `Subject: ${sanitizeHeaderValue(input.subject)}`,
+        ...(input.inReplyTo ? [`In-Reply-To: ${sanitizeHeaderValue(input.inReplyTo)}`] : []),
+        ...(input.references ? [`References: ${sanitizeHeaderValue(input.references)}`] : []),
+        "MIME-Version: 1.0",
+        'Content-Type: text/plain; charset="UTF-8"',
+        "Content-Transfer-Encoding: 8bit",
+        "",
+        input.body.replace(/\r\n/g, "\n"),
+        "",
+    ];
+    return lines.join("\r\n");
+}
+function parseMessageLocator(locatorJson) {
+    const parsed = JSON.parse(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,
+    };
+}
+function latestStoredThreadMessage(threadRef, context) {
+    const messageRef = context.db.listMessageRefsForThread(threadRef)[0] ?? null;
+    return {
+        message_ref: messageRef,
+        stored: messageRef ? context.db.getStoredMessage(messageRef) ?? null : null,
+    };
+}
+function buildSendEnvelope(account, command, status, subject, recipients, result, inReplyToMessageRef) {
+    return {
+        schema_version: "1",
+        command,
+        account: account.name,
+        source: sourceInfo(account),
+        status,
+        subject,
+        recipients,
+        thread_ref: result.thread_ref,
+        message_ref: result.message_ref,
+        in_reply_to_message_ref: inReplyToMessageRef,
+    };
+}
+function buildArchiveEnvelope(account, messageRef, threadRef) {
+    return {
+        schema_version: "1",
+        command: "archive",
+        account: account.name,
+        message_ref: messageRef,
+        thread_ref: threadRef,
+        source: sourceInfo(account),
+        status: "archived",
+    };
+}
+function buildMarkMessagesEnvelope(account, command, updated) {
+    return {
+        schema_version: "1",
+        command,
+        account: account.name,
+        source: sourceInfo(account),
+        updated,
+    };
+}
+function buildReadEnvelope(account, messageRef, threadRef, parsed, attachments, cacheStatus) {
+    return {
+        schema_version: "1",
+        command: "read",
+        account: account.name,
+        message_ref: messageRef,
+        thread_ref: threadRef,
+        source: sourceInfo(account),
+        cache: {
+            status: cacheStatus,
+            truncated: parsed.body.truncated,
+        },
+        message: {
+            envelope: parsed.envelope,
+            body: parsed.body,
+            attachments,
+            ...(parsed.invite ? { invite: parsed.invite } : {}),
+        },
+    };
+}
+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 = [];
+        for (const thread of threads) {
+            const threadId = thread.provider_ids?.thread_id;
+            if (!threadId) {
+                throw new SurfaceError("transport_error", "Gmail thread is missing a thread id.", {
+                    account: account.name,
+                });
+            }
+            const resolvedThreadRef = context.db.findEntityRefByProviderKey("thread", account.account_id, gmailThreadProviderKey(threadId))
+                ?? makeThreadRef();
+            context.db.upsertThread({
+                thread_ref: resolvedThreadRef,
+                account_id: account.account_id,
+                subject: thread.envelope.subject,
+                participants: thread.envelope.participants,
+                mailbox: thread.envelope.mailbox,
+                labels: thread.envelope.labels,
+                received_at: thread.envelope.received_at,
+                message_count: thread.envelope.message_count,
+                unread_count: thread.envelope.unread_count,
+                has_attachments: thread.envelope.has_attachments,
+            });
+            context.db.upsertProviderLocator({
+                entity_kind: "thread",
+                entity_ref: resolvedThreadRef,
+                account_id: account.account_id,
+                provider_key: gmailThreadProviderKey(threadId),
+                locator_json: JSON.stringify(thread.locator?.locator ?? { thread_id: threadId }),
+            });
+            const persistedMessages = [];
+            const messageRefs = [];
+            for (const message of thread.messages) {
+                const messageId = message.provider_ids?.message_id;
+                if (!messageId) {
+                    throw new SurfaceError("transport_error", "Gmail message is missing a message id.", {
+                        account: account.name,
+                        threadRef: resolvedThreadRef,
+                    });
+                }
+                const resolvedMessageRef = context.db.findEntityRefByProviderKey("message", account.account_id, gmailMessageProviderKey(messageId))
+                    ?? makeMessageRef();
+                const messageDir = join(context.accountPaths.messagesDir, resolvedMessageRef);
+                mkdirSync(messageDir, { recursive: true });
+                const bodyCachePath = join(messageDir, "body.txt");
+                writeFileSync(bodyCachePath, message.body.text, "utf8");
+                context.db.upsertMessage({
+                    message_ref: resolvedMessageRef,
+                    account_id: account.account_id,
+                    thread_ref: resolvedThreadRef,
+                    subject: message.envelope.subject ?? thread.envelope.subject,
+                    from_name: message.envelope.from?.name ?? null,
+                    from_email: message.envelope.from?.email ?? null,
+                    to_json: JSON.stringify(message.envelope.to),
+                    cc_json: JSON.stringify(message.envelope.cc),
+                    sent_at: message.envelope.sent_at,
+                    received_at: message.envelope.received_at,
+                    unread: message.envelope.unread,
+                    snippet: message.snippet,
+                    body_cache_path: bodyCachePath,
+                    body_cached: true,
+                    body_truncated: message.body.truncated,
+                    body_cached_bytes: Buffer.byteLength(message.body.text, "utf8"),
+                    invite_json: message.invite ? JSON.stringify(message.invite) : null,
+                });
+                context.db.upsertProviderLocator({
+                    entity_kind: "message",
+                    entity_ref: resolvedMessageRef,
+                    account_id: account.account_id,
+                    provider_key: gmailMessageProviderKey(messageId),
+                    locator_json: JSON.stringify(message.locator?.locator ?? {
+                        thread_id: threadId,
+                        message_id: messageId,
+                    }),
+                });
+                const persistedAttachments = [];
+                for (const [index, attachment] of message.attachments.entries()) {
+                    const providerKey = gmailAttachmentProviderKey(messageId, attachment, index);
+                    const resolvedAttachmentId = context.db.findEntityRefByProviderKey("attachment", account.account_id, providerKey) ?? makeAttachmentId();
+                    context.db.upsertProviderLocator({
+                        entity_kind: "attachment",
+                        entity_ref: resolvedAttachmentId,
+                        account_id: account.account_id,
+                        provider_key: providerKey,
+                        locator_json: JSON.stringify(attachment.locator?.locator ?? {}),
+                    });
+                    persistedAttachments.push({
+                        ...attachment,
+                        attachment_id: resolvedAttachmentId,
+                    });
+                }
+                context.db.replaceAttachments(resolvedMessageRef, persistedAttachments.map((attachment) => ({
+                    attachment_id: attachment.attachment_id,
+                    filename: attachment.filename,
+                    mime_type: attachment.mime_type,
+                    size_bytes: attachment.size_bytes,
+                    inline: attachment.inline,
+                    saved_to: null,
+                })));
+                persistedMessages.push({
+                    ...message,
+                    message_ref: resolvedMessageRef,
+                    body: {
+                        ...message.body,
+                        cached: true,
+                        cached_bytes: Buffer.byteLength(message.body.text, "utf8"),
+                    },
+                    attachments: persistedAttachments,
+                });
+                messageRefs.push(resolvedMessageRef);
+            }
+            context.db.replaceThreadMessages(resolvedThreadRef, messageRefs);
+            if (thread.summary) {
+                context.db.upsertSummary(resolvedThreadRef, thread.summary);
+            }
+            persistedThreads.push({
+                ...thread,
+                thread_ref: resolvedThreadRef,
+                messages: persistedMessages,
+            });
+        }
+        return persistedThreads;
+    });
+}
+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]);
+}
+async function refreshStoredMessage(account, messageRef, context) {
+    const locatorRow = context.db.findProviderLocator("message", messageRef);
+    if (!locatorRow) {
+        throw new SurfaceError("cache_miss", `No provider locator exists for message '${messageRef}'.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    const locator = JSON.parse(locatorRow.locator_json);
+    if (!locator.thread_id) {
+        throw new SurfaceError("transport_error", `Message '${messageRef}' is missing a Gmail thread id.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    await fetchAndPersistGmailThread(account, context, locator.thread_id);
+    const refreshed = context.db.getStoredMessage(messageRef);
+    if (!refreshed) {
+        throw new SurfaceError("not_found", `Message '${messageRef}' could not be refreshed from Gmail.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    return refreshed;
+}
+async function resolveGmailMessageContext(account, messageRef, context) {
+    let stored = context.db.getStoredMessage(messageRef);
+    if (!stored) {
+        throw new SurfaceError("not_found", `Message '${messageRef}' was not found.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    let locatorRow = context.db.findProviderLocator("message", messageRef);
+    if (!locatorRow) {
+        stored = await refreshStoredMessage(account, messageRef, context);
+        locatorRow = context.db.findProviderLocator("message", messageRef);
+    }
+    if (!locatorRow) {
+        throw new SurfaceError("cache_miss", `No provider locator exists for message '${messageRef}'.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    let locator = parseMessageLocator(locatorRow.locator_json);
+    if (!locator.thread_id || !locator.message_id) {
+        stored = await refreshStoredMessage(account, messageRef, context);
+        locatorRow = context.db.findProviderLocator("message", messageRef);
+        if (!locatorRow) {
+            throw new SurfaceError("cache_miss", `No provider locator exists for message '${messageRef}'.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        locator = parseMessageLocator(locatorRow.locator_json);
+    }
+    if (!locator.thread_id || !locator.message_id) {
+        throw new SurfaceError("transport_error", `Message '${messageRef}' is missing Gmail thread or message ids.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    const thread = await getGmailThread(account, context, locator.thread_id);
+    const message = (thread.messages ?? []).find((entry) => entry.id === locator.message_id);
+    if (!message) {
+        throw new SurfaceError("not_found", `Gmail could not find message '${messageRef}' in thread '${locator.thread_id}'.`, {
+            account: account.name,
+            messageRef,
+        });
+    }
+    return {
+        stored,
+        threadId: locator.thread_id,
+        messageId: locator.message_id,
+        thread,
+        message,
+        headers: headerIndex(message.payload?.headers),
+    };
+}
+async function refreshRefsFromGmailResponse(account, context, response) {
+    const threadId = response.threadId ?? null;
+    if (threadId) {
+        await fetchAndPersistGmailThread(account, context, threadId);
+    }
+    const threadRef = threadId
+        ? context.db.findEntityRefByProviderKey("thread", account.account_id, gmailThreadProviderKey(threadId)) ?? null
+        : null;
+    const messageRef = response.id
+        ? context.db.findEntityRefByProviderKey("message", account.account_id, gmailMessageProviderKey(response.id)) ?? null
+        : null;
+    if (threadRef && !messageRef) {
+        const latest = latestStoredThreadMessage(threadRef, context);
+        return {
+            thread_ref: threadRef,
+            message_ref: latest.message_ref,
+        };
+    }
+    return {
+        thread_ref: threadRef,
+        message_ref: messageRef,
+    };
+}
+async function fetchGmailThreads(account, context, options) {
+    const queryParts = [];
+    if (options.kind === "fetch-unread") {
+        queryParts.push("is:unread");
+    }
+    if (options.queryText) {
+        queryParts.push(options.queryText);
+    }
+    const threadStubs = await listGmailThreads(account, context, {
+        maxResults: options.limit,
+        ...(queryParts.length > 0 ? { q: queryParts.join(" ").trim() } : {}),
+    });
+    if (threadStubs.length === 0) {
+        return [];
+    }
+    const hydrated = await Promise.all(threadStubs
+        .map((thread) => thread.id)
+        .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);
+}
+async function sendOrDraftGmailMessage(account, context, payload) {
+    if (payload.draft) {
+        const draft = await createGmailDraft(account, context, {
+            raw: payload.raw,
+            threadId: payload.threadId ?? null,
+        });
+        return {
+            status: "drafted",
+            refs: await refreshRefsFromGmailResponse(account, context, draft.message ?? {}),
+        };
+    }
+    const message = await sendGmailRawMessage(account, context, {
+        raw: payload.raw,
+        threadId: payload.threadId ?? null,
+    });
+    return {
+        status: "sent",
+        refs: await refreshRefsFromGmailResponse(account, context, message),
+    };
+}
+export class GmailApiAdapter {
+    provider = "gmail";
+    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,
+            });
+        }
+        return {
+            status: "authenticated",
+            detail: result.authenticatedEmail
+                ? `Authenticated as ${result.authenticatedEmail}.`
+                : "Gmail OAuth complete.",
+        };
+    }
+    async logout(_account, context) {
+        clearGmailAuthState(context);
+        return {
+            status: "unauthenticated",
+            detail: "Removed the stored Gmail token and copied client secret for this account.",
+        };
+    }
+    async authStatus(account, context) {
+        const status = await gmailAuthStatus(account, context);
+        return status.authenticated
+            ? { status: "authenticated", detail: status.detail }
+            : { status: "unauthenticated", detail: status.detail };
+    }
+    async search(account, query, context) {
+        return fetchGmailThreads(account, context, {
+            kind: "search",
+            queryText: query.text,
+            limit: query.limit,
+        });
+    }
+    async fetchUnread(account, query, context) {
+        return fetchGmailThreads(account, context, {
+            kind: "fetch-unread",
+            limit: query.limit,
+        });
+    }
+    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");
+    }
+    async listAttachments(account, messageRef, context) {
+        const message = context.db.findMessageByRef(messageRef);
+        if (!message) {
+            throw new SurfaceError("not_found", `Message '${messageRef}' was not found.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        return {
+            schema_version: "1",
+            command: "attachment-list",
+            account: account.name,
+            message_ref: messageRef,
+            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),
+            })),
+        };
+    }
+    async downloadAttachment(account, messageRef, attachmentId, context) {
+        const storedMessage = context.db.findMessageByRef(messageRef);
+        if (!storedMessage) {
+            throw new SurfaceError("not_found", `Message '${messageRef}' was not found.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        const attachment = context.db.listAttachmentsForMessage(messageRef).find((entry) => entry.attachment_id === attachmentId);
+        if (!attachment) {
+            throw new SurfaceError("not_found", `Attachment '${attachmentId}' was not found for message '${messageRef}'.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        let locatorRow = context.db.findProviderLocator("attachment", attachmentId);
+        if (!locatorRow) {
+            await refreshStoredMessage(account, messageRef, context);
+            locatorRow = context.db.findProviderLocator("attachment", attachmentId);
+        }
+        if (!locatorRow) {
+            throw new SurfaceError("cache_miss", `No provider locator exists for attachment '${attachmentId}'.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        const locator = JSON.parse(locatorRow.locator_json);
+        let bytes = null;
+        if (locator.inline_data) {
+            bytes = decodeBase64UrlBytes(locator.inline_data);
+        }
+        else if (locator.message_id && locator.attachment_id) {
+            const payload = await downloadGmailAttachmentBytes(account, context, locator.message_id, locator.attachment_id);
+            if (!payload.data) {
+                throw new SurfaceError("transport_error", `Gmail attachment '${attachmentId}' returned no data.`, {
+                    account: account.name,
+                    messageRef,
+                });
+            }
+            bytes = decodeBase64UrlBytes(payload.data);
+        }
+        if (!bytes) {
+            throw new SurfaceError("unsupported", `Attachment '${attachmentId}' does not expose downloadable Gmail bytes.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        const targetDir = join(context.accountPaths.downloadsDir, messageRef);
+        mkdirSync(targetDir, { recursive: true });
+        const targetPath = join(targetDir, `${attachmentId}__${attachment.filename}`);
+        writeFileSync(targetPath, bytes);
+        context.db.updateAttachmentSavedTo(attachmentId, targetPath);
+        return {
+            schema_version: "1",
+            command: "attachment-download",
+            account: account.name,
+            message_ref: messageRef,
+            attachment: {
+                attachment_id: attachmentId,
+                filename: attachment.filename,
+                mime_type: attachment.mime_type,
+                size_bytes: attachment.size_bytes,
+                inline: Boolean(attachment.inline),
+                saved_to: targetPath,
+            },
+        };
+    }
+    async rsvp(account, _messageRef, _response) {
+        notImplemented("Gmail RSVP is deferred pending explicit Google Calendar integration.", account.name);
+    }
+    async sendMessage(account, input, context) {
+        const recipients = {
+            to: normalizeEmailList(input.to),
+            cc: normalizeEmailList(input.cc),
+            bcc: normalizeEmailList(input.bcc),
+        };
+        if (recipients.to.length === 0) {
+            throw new SurfaceError("invalid_argument", "Gmail send requires at least one --to recipient.", {
+                account: account.name,
+            });
+        }
+        assertWriteAllowed(context.config, account, recipients, {
+            disposition: input.draft ? "draft" : "send",
+        });
+        const raw = encodeMimeBase64Url(buildRawMimeMessage({
+            from: account.email,
+            to: recipients.to,
+            cc: recipients.cc,
+            bcc: recipients.bcc,
+            subject: input.subject,
+            body: input.body,
+        }));
+        const result = await sendOrDraftGmailMessage(account, context, {
+            raw,
+            draft: input.draft,
+        });
+        return buildSendEnvelope(account, "send", result.status, input.subject, recipientsFromInput(recipients), result.refs, null);
+    }
+    async reply(account, messageRef, input, context) {
+        const target = await resolveGmailMessageContext(account, messageRef, context);
+        const selfEmail = account.email.trim().toLowerCase();
+        const replyTo = parseMailbox(target.headers["reply-to"]);
+        const from = parseMailbox(target.headers.from);
+        let to = normalizeEmailList([replyTo?.email, from?.email]).filter((email) => email.trim().toLowerCase() !== selfEmail);
+        if (to.length === 0) {
+            to = normalizeEmailList(parseMailboxes(target.headers.to)
+                .map((mailbox) => mailbox.email)
+                .filter((email) => email.trim().toLowerCase() !== selfEmail));
+        }
+        const recipients = {
+            to,
+            cc: normalizeEmailList(input.cc),
+            bcc: normalizeEmailList(input.bcc),
+        };
+        if (recipients.to.length === 0) {
+            throw new SurfaceError("unsupported", `Message '${messageRef}' does not expose a reply target.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        assertWriteAllowed(context.config, account, recipients, {
+            disposition: input.draft ? "draft" : "send",
+        });
+        const originalMessageId = target.headers["message-id"] ?? null;
+        const references = target.headers.references
+            ? `${target.headers.references}${originalMessageId ? ` ${originalMessageId}` : ""}`.trim()
+            : originalMessageId;
+        const subject = prefixSubject(target.stored.subject ?? target.headers.subject ?? "", "Re");
+        const raw = encodeMimeBase64Url(buildRawMimeMessage({
+            from: account.email,
+            to: recipients.to,
+            cc: recipients.cc,
+            bcc: recipients.bcc,
+            subject,
+            body: buildReplyBody(input.body, target.stored),
+            inReplyTo: originalMessageId,
+            references,
+        }));
+        const result = await sendOrDraftGmailMessage(account, context, {
+            raw,
+            threadId: target.threadId,
+            draft: input.draft,
+        });
+        return buildSendEnvelope(account, "reply", result.status, subject, recipientsFromInput(recipients), result.refs, messageRef);
+    }
+    async replyAll(account, messageRef, input, context) {
+        const target = await resolveGmailMessageContext(account, messageRef, context);
+        const selfEmail = account.email.trim().toLowerCase();
+        const replyTo = parseMailbox(target.headers["reply-to"]);
+        const from = parseMailbox(target.headers.from);
+        const originalTo = parseMailboxes(target.headers.to).map((mailbox) => mailbox.email);
+        const originalCc = parseMailboxes(target.headers.cc).map((mailbox) => mailbox.email);
+        let to = normalizeEmailList([
+            replyTo?.email && replyTo.email.trim().toLowerCase() !== selfEmail ? replyTo.email : null,
+            from?.email && from.email.trim().toLowerCase() !== selfEmail ? from.email : null,
+        ]);
+        if (to.length === 0) {
+            to = normalizeEmailList(originalTo.filter((email) => email.trim().toLowerCase() !== selfEmail));
+        }
+        if (to.length === 0 && from?.email) {
+            to = normalizeEmailList([from.email]);
+        }
+        const cc = normalizeEmailList([
+            ...originalTo.filter((email) => !to.includes(email) && email.trim().toLowerCase() !== selfEmail),
+            ...originalCc.filter((email) => !to.includes(email) && email.trim().toLowerCase() !== selfEmail),
+            ...input.cc,
+        ]);
+        const bcc = normalizeEmailList(input.bcc);
+        const recipients = { to, cc, bcc };
+        if (recipients.to.length === 0) {
+            throw new SurfaceError("unsupported", `Message '${messageRef}' does not expose reply-all recipients.`, {
+                account: account.name,
+                messageRef,
+            });
+        }
+        assertWriteAllowed(context.config, account, recipients, {
+            disposition: input.draft ? "draft" : "send",
+        });
+        const originalMessageId = target.headers["message-id"] ?? null;
+        const references = target.headers.references
+            ? `${target.headers.references}${originalMessageId ? ` ${originalMessageId}` : ""}`.trim()
+            : originalMessageId;
+        const subject = prefixSubject(target.stored.subject ?? target.headers.subject ?? "", "Re");
+        const raw = encodeMimeBase64Url(buildRawMimeMessage({
+            from: account.email,
+            to: recipients.to,
+            cc: recipients.cc,
+            bcc: recipients.bcc,
+            subject,
+            body: buildReplyBody(input.body, target.stored),
+            inReplyTo: originalMessageId,
+            references,
+        }));
+        const result = await sendOrDraftGmailMessage(account, context, {
+            raw,
+            threadId: target.threadId,
+            draft: input.draft,
+        });
+        return buildSendEnvelope(account, "reply-all", result.status, subject, recipientsFromInput(recipients), result.refs, messageRef);
+    }
+    async forward(account, messageRef, input, context) {
+        const target = await resolveGmailMessageContext(account, messageRef, context);
+        const recipients = {
+            to: normalizeEmailList(input.to),
+            cc: normalizeEmailList(input.cc),
+            bcc: normalizeEmailList(input.bcc),
+        };
+        if (recipients.to.length === 0) {
+            throw new SurfaceError("invalid_argument", "Gmail forward requires at least one --to recipient.", {
+                account: account.name,
+            });
+        }
+        assertWriteAllowed(context.config, account, recipients, {
+            disposition: input.draft ? "draft" : "send",
+        });
+        const subject = prefixSubject(target.stored.subject ?? target.headers.subject ?? "", "Fwd");
+        const raw = encodeMimeBase64Url(buildRawMimeMessage({
+            from: account.email,
+            to: recipients.to,
+            cc: recipients.cc,
+            bcc: recipients.bcc,
+            subject,
+            body: buildForwardBody(input.body, target.stored),
+        }));
+        const result = await sendOrDraftGmailMessage(account, context, {
+            raw,
+            draft: input.draft,
+        });
+        return buildSendEnvelope(account, "forward", result.status, subject, recipientsFromInput(recipients), result.refs, messageRef);
+    }
+    async archive(account, messageRef, context) {
+        assertWriteAllowed(context.config, account, { to: [], cc: [], bcc: [] }, { disposition: "non_send" });
+        const target = await resolveGmailMessageContext(account, messageRef, context);
+        await modifyGmailThread(account, context, target.threadId, {
+            removeLabelIds: ["INBOX"],
+        });
+        await fetchAndPersistGmailThread(account, context, target.threadId);
+        return buildArchiveEnvelope(account, messageRef, target.stored.thread_ref);
+    }
+    async markRead(account, messageRefs, context) {
+        assertWriteAllowed(context.config, account, { to: [], cc: [], bcc: [] }, { disposition: "non_send" });
+        const touchedThreadIds = new Set();
+        const updated = [];
+        for (const messageRef of messageRefs) {
+            const target = await resolveGmailMessageContext(account, messageRef, context);
+            await modifyGmailMessage(account, context, target.messageId, {
+                removeLabelIds: ["UNREAD"],
+            });
+            touchedThreadIds.add(target.threadId);
+            updated.push({
+                message_ref: messageRef,
+                thread_ref: target.stored.thread_ref,
+                unread: false,
+            });
+        }
+        for (const threadId of touchedThreadIds) {
+            await fetchAndPersistGmailThread(account, context, threadId);
+        }
+        return buildMarkMessagesEnvelope(account, "mark-read", updated);
+    }
+    async markUnread(account, messageRefs, context) {
+        assertWriteAllowed(context.config, account, { to: [], cc: [], bcc: [] }, { disposition: "non_send" });
+        const touchedThreadIds = new Set();
+        const updated = [];
+        for (const messageRef of messageRefs) {
+            const target = await resolveGmailMessageContext(account, messageRef, context);
+            await modifyGmailMessage(account, context, target.messageId, {
+                addLabelIds: ["UNREAD"],
+            });
+            touchedThreadIds.add(target.threadId);
+            updated.push({
+                message_ref: messageRef,
+                thread_ref: target.stored.thread_ref,
+                unread: true,
+            });
+        }
+        for (const threadId of touchedThreadIds) {
+            await fetchAndPersistGmailThread(account, context, threadId);
+        }
+        return buildMarkMessagesEnvelope(account, "mark-unread", updated);
+    }
+}
+//# sourceMappingURL=adapter.js.map