@agent-native/core 0.102.1 → 0.103.0

package/corpus/templates/mail/server/lib/google-auth.ts

@@ -14,6 +14,7 @@ import {
 import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import { decodeCommonHtmlEntities } from "@shared/markdown.js";
 
+import type { BulkMarkReadResult } from "./bulk-mark-read.js";
 import {
   createOAuth2Client,
   gmailGetProfile,
@@ -31,6 +32,7 @@ import {
   peopleGetProfile,
 } from "./google-api.js";
 import { resolveGoogleSenderIdentity } from "./sender-identity.js";
+import { invalidateThreadCache } from "./thread-cache.js";
 
 const SCOPES = [
   "https://www.googleapis.com/auth/gmail.readonly",
@@ -1776,25 +1778,44 @@ export async function fetchGmailLabelMap(
 // instead of one per message.
 const GMAIL_BATCH_MODIFY_MAX_IDS = 1000;
 
+interface GmailBatchModifyResult {
+  succeeded: string[];
+  failed: Array<{ id: string; error: string }>;
+  batchCount: number;
+}
+
 async function gmailBatchModify(
   accessToken: string,
   ids: string[],
   addLabelIds?: string[],
   removeLabelIds?: string[],
-): Promise<void> {
-  if (ids.length === 0) return;
+): Promise<GmailBatchModifyResult> {
+  const result: GmailBatchModifyResult = {
+    succeeded: [],
+    failed: [],
+    batchCount: 0,
+  };
+  if (ids.length === 0) return result;
   for (let i = 0; i < ids.length; i += GMAIL_BATCH_MODIFY_MAX_IDS) {
     const chunk = ids.slice(i, i + GMAIL_BATCH_MODIFY_MAX_IDS);
-    await googleFetch(
-      "https://gmail.googleapis.com/gmail/v1/users/me/messages/batchModify",
-      accessToken,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ ids: chunk, addLabelIds, removeLabelIds }),
-      },
-    );
+    result.batchCount += 1;
+    try {
+      await googleFetch(
+        "https://gmail.googleapis.com/gmail/v1/users/me/messages/batchModify",
+        accessToken,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ids: chunk, addLabelIds, removeLabelIds }),
+        },
+      );
+      result.succeeded.push(...chunk);
+    } catch (err: any) {
+      const error = err?.message ?? "batchModify failed";
+      result.failed.push(...chunk.map((id) => ({ id, error })));
+    }
   }
+  return result;
 }
 
 export interface BatchModifyTarget {
@@ -1826,7 +1847,7 @@ export async function gmailBatchModifyByAccount(
 ): Promise<BatchModifyByAccountResult> {
   const byAccount = new Map<string, BatchModifyTarget[]>();
   for (const target of targets) {
-    const key = target.accountEmail || ownerEmail;
+    const key = target.accountEmail || "";
     const list = byAccount.get(key);
     if (list) list.push(target);
     else byAccount.set(key, [target]);
@@ -1836,24 +1857,18 @@ export async function gmailBatchModifyByAccount(
   const failed: Array<{ id: string; error: string }> = [];
 
   for (const [accountEmail, accountTargets] of byAccount) {
-    const client = await getClient(accountEmail);
-    if (!client) {
-      for (const t of accountTargets) {
-        failed.push({
-          id: t.id,
-          error: `Account ${accountEmail} not connected`,
-        });
-      }
-      continue;
-    }
     try {
-      await gmailBatchModify(
-        client.accessToken,
+      const accessToken = accountEmail
+        ? await getOwnedAccountAccessToken(ownerEmail, accountEmail)
+        : await getDefaultOwnedAccountAccessToken(ownerEmail);
+      const result = await gmailBatchModify(
+        accessToken,
         accountTargets.map((t) => t.id),
         addLabelIds,
         removeLabelIds,
       );
-      for (const t of accountTargets) succeeded.push(t.id);
+      succeeded.push(...result.succeeded);
+      failed.push(...result.failed);
     } catch (err: any) {
       const message = err?.message ?? "batchModify failed";
       for (const t of accountTargets) failed.push({ id: t.id, error: message });
@@ -1863,6 +1878,184 @@ export async function gmailBatchModifyByAccount(
   return { succeeded, failed };
 }
 
+interface GmailMessageReference {
+  id: string;
+  threadId: string;
+}
+
+async function getDefaultOwnedAccountAccessToken(
+  ownerEmail: string,
+): Promise<string> {
+  const accounts = await listOAuthAccountsByOwner("google", ownerEmail);
+  const account =
+    accounts.find(
+      (candidate) =>
+        candidate.accountId.toLowerCase() === ownerEmail.toLowerCase(),
+    ) ?? accounts[0];
+  if (!account) throw new Error("No Google account connected");
+  const tokens = account.tokens as unknown as GoogleTokens;
+  if (!tokens?.access_token && !tokens?.refresh_token) {
+    throw new Error(`No valid access token for ${account.accountId}`);
+  }
+  return getValidAccessToken(account.accountId, tokens, ownerEmail);
+}
+
+async function getOwnedAccountAccessToken(
+  ownerEmail: string,
+  accountEmail: string,
+): Promise<string> {
+  const accounts = await listOAuthAccountsByOwner("google", ownerEmail);
+  const account = accounts.find(
+    (candidate) =>
+      candidate.accountId.toLowerCase() === accountEmail.toLowerCase(),
+  );
+  if (!account) {
+    throw new Error(`Account ${accountEmail} is not connected for this user`);
+  }
+  const tokens = account.tokens as unknown as GoogleTokens;
+  if (!tokens?.access_token && !tokens?.refresh_token) {
+    throw new Error(`No valid access token for ${account.accountId}`);
+  }
+  return getValidAccessToken(account.accountId, tokens, ownerEmail);
+}
+
+async function listGmailMessageReferences(
+  accessToken: string,
+  query: string,
+): Promise<GmailMessageReference[]> {
+  const references = new Map<string, GmailMessageReference>();
+  const seenPageTokens = new Set<string>();
+  let pageToken: string | undefined;
+
+  do {
+    const response = await gmailListMessages(accessToken, {
+      q: query,
+      maxResults: 500,
+      pageToken,
+    });
+    for (const message of response.messages ?? []) {
+      if (
+        typeof message.id !== "string" ||
+        typeof message.threadId !== "string"
+      )
+        continue;
+      references.set(message.id, {
+        id: message.id,
+        threadId: message.threadId,
+      });
+    }
+
+    const nextPageToken = response.nextPageToken;
+    if (typeof nextPageToken !== "string" || !nextPageToken) break;
+    if (seenPageTokens.has(nextPageToken)) {
+      throw new Error(
+        "Gmail repeated a pagination token while listing unread mail",
+      );
+    }
+    seenPageTokens.add(nextPageToken);
+    pageToken = nextPageToken;
+  } while (pageToken);
+
+  return [...references.values()];
+}
+
+export async function markAllUnreadReadForAccount(input: {
+  ownerEmail: string;
+  accountEmail: string;
+  excludeThreadIds: string[];
+}): Promise<BulkMarkReadResult> {
+  const { ownerEmail, accountEmail } = input;
+  const excludedThreadIds = new Set(input.excludeThreadIds.filter(Boolean));
+  const accessToken = await getOwnedAccountAccessToken(
+    ownerEmail,
+    accountEmail,
+  );
+  const matched = await listGmailMessageReferences(accessToken, "is:unread");
+  const excluded = matched.filter((message) =>
+    excludedThreadIds.has(message.threadId),
+  );
+  const selected = matched.filter(
+    (message) => !excludedThreadIds.has(message.threadId),
+  );
+
+  const mutation = await gmailBatchModify(
+    accessToken,
+    selected.map((message) => message.id),
+    undefined,
+    ["UNREAD"],
+  );
+  for (const threadId of new Set(selected.map((message) => message.threadId))) {
+    invalidateThreadCache(ownerEmail, threadId);
+  }
+  invalidateListCacheForOwner(ownerEmail);
+
+  let remaining: GmailMessageReference[];
+  try {
+    remaining = await listGmailMessageReferences(accessToken, "is:unread");
+  } catch (err: any) {
+    return {
+      mode: "all-unread",
+      accountEmail,
+      matchedMessages: matched.length,
+      matchedThreads: new Set(matched.map((message) => message.threadId)).size,
+      excludedMessages: excluded.length,
+      excludedThreads: new Set(excluded.map((message) => message.threadId))
+        .size,
+      changedMessages: mutation.succeeded.length,
+      batchCount: mutation.batchCount,
+      failures: mutation.failed,
+      remainingUnreadMessages: null,
+      remainingUnreadThreads: null,
+      remainingProtectedMessages: null,
+      remainingProtectedThreads: null,
+      unexpectedUnreadMessages: null,
+      unexpectedUnreadThreads: null,
+      newUnreadMessages: null,
+      newUnreadThreads: null,
+      verificationComplete: false,
+      verificationError: err?.message ?? "Unread verification failed",
+    };
+  }
+  const matchedIds = new Set(matched.map((message) => message.id));
+  const selectedIds = new Set(selected.map((message) => message.id));
+  const remainingProtected = remaining.filter((message) =>
+    excludedThreadIds.has(message.threadId),
+  );
+  const unexpectedRemaining = remaining.filter((message) =>
+    selectedIds.has(message.id),
+  );
+  const newUnread = remaining.filter((message) => !matchedIds.has(message.id));
+
+  return {
+    mode: "all-unread",
+    accountEmail,
+    matchedMessages: matched.length,
+    matchedThreads: new Set(matched.map((message) => message.threadId)).size,
+    excludedMessages: excluded.length,
+    excludedThreads: new Set(excluded.map((message) => message.threadId)).size,
+    changedMessages: mutation.succeeded.length,
+    batchCount: mutation.batchCount,
+    failures: mutation.failed,
+    remainingUnreadMessages: remaining.length,
+    remainingUnreadThreads: new Set(
+      remaining.map((message) => message.threadId),
+    ).size,
+    remainingProtectedMessages: remainingProtected.length,
+    remainingProtectedThreads: new Set(
+      remainingProtected.map((message) => message.threadId),
+    ).size,
+    unexpectedUnreadMessages: unexpectedRemaining.length,
+    unexpectedUnreadThreads: new Set(
+      unexpectedRemaining.map((message) => message.threadId),
+    ).size,
+    newUnreadMessages: newUnread.length,
+    newUnreadThreads: new Set(newUnread.map((message) => message.threadId))
+      .size,
+    verificationComplete:
+      mutation.failed.length === 0 && unexpectedRemaining.length === 0,
+  };
+}
+
 /** Extract regular (non-inline) attachments from a Gmail message payload */
 function getAttachments(
   payload: any,

package/corpus/templates/mail/server/lib/jobs.ts

@@ -5,7 +5,6 @@ import {
   listOAuthAccountsByOwner,
   setOAuthDisplayName,
 } from "@agent-native/core/oauth-tokens";
-import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import { markdownPreviewSnippet } from "@shared/markdown.js";
 import type { ComposeAttachment, EmailMessage } from "@shared/types.js";
 import { and, eq, inArray, isNull, lte, or } from "drizzle-orm";
@@ -28,6 +27,11 @@ import {
   getOAuth2Credentials,
   setAccountDisplayName,
 } from "./google-auth.js";
+import {
+  readLocalEmails as readEmails,
+  withLocalEmailMutationLock,
+  writeLocalEmails as writeEmails,
+} from "./local-email-store.js";
 import {
   bodyToHtml as outgoingBodyToHtml,
   buildRawEmail as buildOutgoingRawEmail,
@@ -135,21 +139,6 @@ async function getFirstAccountToken(
   return null;
 }
 
-async function readEmails(ownerEmail: string): Promise<EmailMessage[]> {
-  const data = await getUserSetting(ownerEmail, "local-emails");
-  if (data && Array.isArray((data as any).emails)) {
-    return (data as any).emails;
-  }
-  return [];
-}
-
-async function writeEmails(
-  ownerEmail: string,
-  emails: EmailMessage[],
-): Promise<void> {
-  await putUserSetting(ownerEmail, "local-emails", { emails });
-}
-
 async function fetchLabelMap(
   accessToken: string,
 ): Promise<Map<string, string>> {
@@ -211,18 +200,20 @@ async function archiveThreadForSnooze(
     }
   }
 
-  const emails = await readEmails(ownerEmail);
-  for (let i = 0; i < emails.length; i++) {
-    const currentThreadId = emails[i].threadId || emails[i].id;
-    if (currentThreadId === threadId) {
-      emails[i] = {
-        ...emails[i],
-        isArchived: true,
-        labelIds: emails[i].labelIds.filter((label) => label !== "inbox"),
-      };
+  await withLocalEmailMutationLock(ownerEmail, async () => {
+    const emails = await readEmails(ownerEmail);
+    for (let i = 0; i < emails.length; i++) {
+      const currentThreadId = emails[i].threadId || emails[i].id;
+      if (currentThreadId === threadId) {
+        emails[i] = {
+          ...emails[i],
+          isArchived: true,
+          labelIds: emails[i].labelIds.filter((label) => label !== "inbox"),
+        };
+      }
     }
-  }
-  await writeEmails(ownerEmail, emails);
+    await writeEmails(ownerEmail, emails);
+  });
 }
 
 async function threadHasReplySinceSnooze(
@@ -396,22 +387,24 @@ export async function resurfaceEmail(
     }
   }
 
-  const emails = await readEmails(ownerEmail);
-  const targetThreadId = threadId || emailId;
-  for (let i = 0; i < emails.length; i++) {
-    const currentThreadId = emails[i].threadId || emails[i].id;
-    if (currentThreadId === targetThreadId) {
-      emails[i] = {
-        ...emails[i],
-        isArchived: false,
-        isRead: false,
-        labelIds: emails[i].labelIds.includes("inbox")
-          ? emails[i].labelIds
-          : ["inbox", ...emails[i].labelIds],
-      };
+  await withLocalEmailMutationLock(ownerEmail, async () => {
+    const emails = await readEmails(ownerEmail);
+    const targetThreadId = threadId || emailId;
+    for (let i = 0; i < emails.length; i++) {
+      const currentThreadId = emails[i].threadId || emails[i].id;
+      if (currentThreadId === targetThreadId) {
+        emails[i] = {
+          ...emails[i],
+          isArchived: false,
+          isRead: false,
+          labelIds: emails[i].labelIds.includes("inbox")
+            ? emails[i].labelIds
+            : ["inbox", ...emails[i].labelIds],
+        };
+      }
     }
-  }
-  await writeEmails(ownerEmail, emails);
+    await writeEmails(ownerEmail, emails);
+  });
 }
 
 /**
@@ -638,39 +631,41 @@ export async function sendScheduledEmail(
   if (!fallbackOwner) {
     throw new Error("scheduleEmail: no owner email available");
   }
-  const emails = await readEmails(fallbackOwner);
-  emails.push({
-    id: `msg-${nanoid(8)}`,
-    threadId: threadId || `thread-${nanoid(8)}`,
-    from: { name: fallbackOwner, email: fallbackOwner },
-    to: to.split(",").map((item) => {
-      const email = item.trim();
-      return { name: email, email };
-    }),
-    subject,
-    snippet: markdownPreviewSnippet(body),
-    body,
-    bodyHtml: outgoingBodyToHtml(body),
-    date: new Date().toISOString(),
-    isRead: true,
-    isStarred: false,
-    isSent: true,
-    isArchived: false,
-    isTrashed: false,
-    labelIds: ["sent"],
-    ...(attachments.length > 0
-      ? {
-          attachments: attachments.map((att) => ({
-            id: att.filename,
-            filename: att.originalName,
-            mimeType: att.mimeType,
-            size: att.size,
-            url: att.url,
-          })),
-        }
-      : {}),
+  await withLocalEmailMutationLock(fallbackOwner, async () => {
+    const emails = await readEmails(fallbackOwner);
+    emails.push({
+      id: `msg-${nanoid(8)}`,
+      threadId: threadId || `thread-${nanoid(8)}`,
+      from: { name: fallbackOwner, email: fallbackOwner },
+      to: to.split(",").map((item) => {
+        const email = item.trim();
+        return { name: email, email };
+      }),
+      subject,
+      snippet: markdownPreviewSnippet(body),
+      body,
+      bodyHtml: outgoingBodyToHtml(body),
+      date: new Date().toISOString(),
+      isRead: true,
+      isStarred: false,
+      isSent: true,
+      isArchived: false,
+      isTrashed: false,
+      labelIds: ["sent"],
+      ...(attachments.length > 0
+        ? {
+            attachments: attachments.map((att) => ({
+              id: att.filename,
+              filename: att.originalName,
+              mimeType: att.mimeType,
+              size: att.size,
+              url: att.url,
+            })),
+          }
+        : {}),
+    });
+    await writeEmails(fallbackOwner, emails);
   });
-  await writeEmails(fallbackOwner, emails);
 }
 
 export async function cancelScheduledJobForOwner(