@1kbirds/chidori-mock-gmail 0.1.0

package/src/client.ts

@@ -0,0 +1,54 @@
+import type { GmailMock } from "./service";
+import type { GmailLabel, GmailMessage, GmailModifyRequest, GmailSearchOptions, GmailSendRequest } from "./types";
+
+function response<T>(data: T, status = 200, statusText = "OK") {
+  return { data, status, statusText, headers: {} };
+}
+
+export function createGmailClient(mock: GmailMock) {
+  return {
+    users: {
+      getProfile: async ({ userId: _userId = "me" }: { userId?: string } = {}) => response(mock.getProfile()),
+      labels: {
+        list: async ({ userId: _userId = "me" }: { userId?: string } = {}) => response(mock.listLabels()),
+        get: async ({ id }: { userId?: string; id: string }) => response(mock.getLabel(id)),
+        create: async ({ requestBody }: { userId?: string; requestBody: Partial<GmailLabel> }) => response(mock.createLabel(requestBody)),
+        update: async ({ id, requestBody }: { userId?: string; id: string; requestBody: Partial<GmailLabel> }) => response(mock.updateLabel(id, requestBody)),
+        delete: async ({ id }: { userId?: string; id: string }) => {
+          mock.deleteLabel(id);
+          return response(undefined, 204, "No Content");
+        },
+      },
+      messages: {
+        list: async (params: GmailSearchOptions & { userId?: string } = {}) => response(mock.listMessages(params)),
+        get: async ({ id }: { userId?: string; id: string }) => response(mock.getMessage(id)),
+        insert: async ({ requestBody }: { userId?: string; requestBody: Partial<GmailMessage> | GmailSendRequest }) => response(mock.insertMessage(requestBody)),
+        send: async ({ requestBody }: { userId?: string; requestBody: GmailSendRequest }) => response(mock.send(requestBody)),
+        modify: async ({ id, requestBody }: { userId?: string; id: string; requestBody: GmailModifyRequest }) => response(mock.modifyMessage(id, requestBody)),
+        trash: async ({ id }: { userId?: string; id: string }) => response(mock.trashMessage(id)),
+        untrash: async ({ id }: { userId?: string; id: string }) => response(mock.untrashMessage(id)),
+        delete: async ({ id }: { userId?: string; id: string }) => {
+          mock.deleteMessage(id);
+          return response(undefined, 204, "No Content");
+        },
+      },
+      threads: {
+        list: async (params: GmailSearchOptions & { userId?: string } = {}) => response(mock.listThreads(params)),
+        get: async ({ id }: { userId?: string; id: string }) => response(mock.getThread(id)),
+        modify: async ({ id, requestBody }: { userId?: string; id: string; requestBody: GmailModifyRequest }) => response(mock.modifyThread(id, requestBody)),
+        trash: async ({ id }: { userId?: string; id: string }) => response(mock.trashThread(id)),
+      },
+      drafts: {
+        list: async () => response(mock.listDrafts()),
+        get: async ({ id }: { userId?: string; id: string }) => response(mock.getDraft(id)),
+        create: async ({ requestBody }: { userId?: string; requestBody: GmailSendRequest }) => response(mock.createDraft(requestBody)),
+        update: async ({ id, requestBody }: { userId?: string; id: string; requestBody: GmailSendRequest }) => response(mock.updateDraft(id, requestBody)),
+        send: async ({ id }: { userId?: string; id: string }) => response(mock.sendDraft(id)),
+        delete: async ({ id }: { userId?: string; id: string }) => {
+          mock.deleteDraft(id);
+          return response(undefined, 204, "No Content");
+        },
+      },
+    },
+  };
+}

package/src/errors.ts

@@ -0,0 +1,29 @@
+export class GmailMockError extends Error {
+  readonly status: number;
+  readonly reason: string;
+
+  constructor(status: number, reason: string, message: string) {
+    super(message);
+    this.name = "GmailMockError";
+    this.status = status;
+    this.reason = reason;
+  }
+
+  toJSON() {
+    return {
+      error: {
+        code: this.status,
+        message: this.message,
+        errors: [{ domain: "global", reason: this.reason, message: this.message }],
+      },
+    };
+  }
+}
+
+export function badRequest(message: string): GmailMockError {
+  return new GmailMockError(400, "badRequest", message);
+}
+
+export function notFound(message: string): GmailMockError {
+  return new GmailMockError(404, "notFound", message);
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export { handleGmailApiRequest } from "./api";
+export type { GmailApiRequest, GmailApiResponse } from "./api";
+export { createGmailClient } from "./client";
+export { GmailMockError } from "./errors";
+export { decodeBase64Url, encodeBase64Url, GmailMock } from "./service";
+import { GmailMock } from "./service";
+export { demoDrafts, demoMessages, demoSeed, demoUser } from "./seed";
+export type * from "./types";
+
+export function createGmailMock(...args: ConstructorParameters<typeof GmailMock>): GmailMock {
+  return new GmailMock(...args);
+}

package/src/seed.ts

@@ -0,0 +1,143 @@
+import { encodeBase64Url } from "./service";
+import { defaultLabels } from "./state";
+import type { GmailDraft, GmailMessage, GmailSeed, GmailUser } from "./types";
+
+export const demoUser: GmailUser = {
+  id: "me",
+  emailAddress: "ada@example.com",
+  displayName: "Ada Lovelace",
+};
+
+function message(input: {
+  id: string;
+  threadId?: string;
+  labels: string[];
+  from: string;
+  to: string;
+  subject: string;
+  body: string;
+  date: string;
+  attachments?: Array<{ id: string; filename: string; mimeType: string; size: number; data?: string }>;
+}): GmailMessage {
+  const threadId = input.threadId ?? input.id;
+  return {
+    id: input.id,
+    threadId,
+    labelIds: input.labels,
+    snippet: input.body.replace(/\s+/g, " ").slice(0, 160),
+    historyId: "1",
+    internalDate: String(new Date(input.date).getTime()),
+    sizeEstimate: input.body.length,
+    attachments: input.attachments,
+    payload: {
+      partId: "",
+      mimeType: "text/plain",
+      filename: "",
+      headers: [
+        { name: "From", value: input.from },
+        { name: "To", value: input.to },
+        { name: "Subject", value: input.subject },
+        { name: "Date", value: new Date(input.date).toUTCString() },
+      ],
+      body: {
+        size: input.body.length,
+        data: encodeBase64Url(input.body),
+      },
+      parts: input.attachments?.map((attachment, index) => ({
+        partId: String(index + 1),
+        mimeType: attachment.mimeType,
+        filename: attachment.filename,
+        headers: [{ name: "Content-Disposition", value: `attachment; filename="${attachment.filename}"` }],
+        body: { attachmentId: attachment.id, size: attachment.size, data: attachment.data },
+      })),
+    },
+  };
+}
+
+export const demoMessages: GmailMessage[] = [
+  message({
+    id: "msg_schedule_request",
+    labels: ["INBOX", "UNREAD", "IMPORTANT", "CATEGORY_PRIMARY"],
+    from: "morgan@example.com",
+    to: "ada@example.com",
+    subject: "Can we meet this week?",
+    body: "Hi Ada, can we meet this week to review the launch timeline? Tuesday or Wednesday afternoon would work for me.",
+    date: "2026-06-01T16:10:00.000Z",
+  }),
+  message({
+    id: "msg_launch_brief",
+    labels: ["INBOX", "CATEGORY_PRIMARY"],
+    from: "grace@example.com",
+    to: "ada@example.com",
+    subject: "Launch brief attached",
+    body: "Attached is the current launch brief. Please review the owner list before our planning session.",
+    date: "2026-06-01T15:40:00.000Z",
+    attachments: [{ id: "att_launch_brief", filename: "launch-brief.txt", mimeType: "text/plain", size: 128, data: encodeBase64Url("Launch brief fixture") }],
+  }),
+  message({
+    id: "msg_reply_thread_1",
+    threadId: "thread_customer",
+    labels: ["INBOX", "CATEGORY_PRIMARY"],
+    from: "customer@example.com",
+    to: "ada@example.com",
+    subject: "Re: Proposal questions",
+    body: "Thanks for the proposal. Could you clarify implementation timing and support coverage?",
+    date: "2026-05-31T18:00:00.000Z",
+  }),
+  message({
+    id: "msg_reply_thread_2",
+    threadId: "thread_customer",
+    labels: ["SENT"],
+    from: "ada@example.com",
+    to: "customer@example.com",
+    subject: "Re: Proposal questions",
+    body: "Happy to clarify. Implementation typically takes two weeks and support coverage is included.",
+    date: "2026-05-31T19:00:00.000Z",
+  }),
+  message({
+    id: "msg_newsletter",
+    labels: ["TRASH"],
+    from: "newsletter@example.com",
+    to: "ada@example.com",
+    subject: "Weekly digest",
+    body: "A weekly digest that has been moved to trash.",
+    date: "2026-05-30T12:00:00.000Z",
+  }),
+];
+
+export const demoDrafts: GmailDraft[] = [
+  {
+    id: "draft_followup",
+    message: message({
+      id: "msg_draft_followup",
+      labels: ["DRAFT"],
+      from: "ada@example.com",
+      to: "morgan@example.com",
+      subject: "Re: Can we meet this week?",
+      body: "Hi Morgan, Tuesday afternoon works. I can send a calendar invite.",
+      date: "2026-06-01T16:20:00.000Z",
+    }),
+  },
+];
+
+export const demoSeed: GmailSeed = {
+  users: [demoUser],
+  currentUserId: demoUser.id,
+  labels: [
+    ...defaultLabels(),
+    {
+      id: "Label_customers",
+      name: "Customers",
+      type: "user",
+      messageListVisibility: "show",
+      labelListVisibility: "labelShow",
+      color: { textColor: "#ffffff", backgroundColor: "#0b8043" },
+      messagesTotal: 0,
+      messagesUnread: 0,
+      threadsTotal: 0,
+      threadsUnread: 0,
+    },
+  ],
+  messages: demoMessages,
+  drafts: demoDrafts,
+};

package/src/service.ts

@@ -0,0 +1,405 @@
+import { badRequest, notFound } from "./errors";
+import { applySnapshot, bumpHistory, clone, createStore, emit, snapshot, type GmailMockStore } from "./state";
+import type {
+  GmailDraft,
+  GmailLabel,
+  GmailListResponse,
+  GmailMessage,
+  GmailMessagePart,
+  GmailMockOptions,
+  GmailModifyRequest,
+  GmailProfile,
+  GmailSearchOptions,
+  GmailSendRequest,
+  GmailSnapshot,
+  GmailThread,
+} from "./types";
+
+export class GmailMock {
+  readonly store: GmailMockStore;
+  private readonly initialSnapshot: GmailSnapshot;
+
+  constructor(options: GmailMockOptions = {}) {
+    this.store = createStore(options);
+    this.initialSnapshot = snapshot(this.store);
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.store.listeners.add(listener);
+    return () => this.store.listeners.delete(listener);
+  }
+
+  snapshot(): GmailSnapshot {
+    return snapshot(this.store);
+  }
+
+  reset(seed?: GmailSnapshot): void {
+    applySnapshot(this.store, seed ?? this.initialSnapshot);
+  }
+
+  getProfile(): GmailProfile {
+    const user = this.currentUser();
+    return {
+      emailAddress: user.emailAddress,
+      messagesTotal: this.visibleMessages({ includeSpamTrash: true }).length,
+      threadsTotal: this.listThreads({ includeSpamTrash: true }).threads?.length ?? 0,
+      historyId: String(this.store.historyId),
+    };
+  }
+
+  listLabels(): GmailListResponse<GmailLabel> {
+    return {
+      resultSizeEstimate: this.store.labels.size,
+      labels: Array.from(this.store.labels.values()).map(clone),
+    };
+  }
+
+  getLabel(id: string): GmailLabel {
+    const label = this.store.labels.get(id);
+    if (!label) throw notFound(`Label not found: ${id}`);
+    return clone(label);
+  }
+
+  createLabel(input: Partial<GmailLabel>): GmailLabel {
+    if (!input.name) throw badRequest("Missing required field: name");
+    const id = input.id ?? `Label_${this.store.nextId("label")}`;
+    if (this.store.labels.has(id)) throw badRequest(`Label already exists: ${id}`);
+    const label: GmailLabel = {
+      id,
+      name: input.name,
+      type: "user",
+      messageListVisibility: input.messageListVisibility ?? "show",
+      labelListVisibility: input.labelListVisibility ?? "labelShow",
+      color: input.color,
+      messagesTotal: 0,
+      messagesUnread: 0,
+      threadsTotal: 0,
+      threadsUnread: 0,
+    };
+    this.store.labels.set(id, label);
+    bumpHistory(this.store);
+    emit(this.store);
+    return clone(label);
+  }
+
+  updateLabel(id: string, input: Partial<GmailLabel>): GmailLabel {
+    const existing = this.getLabel(id);
+    const next = { ...existing, ...input, id, type: existing.type };
+    this.store.labels.set(id, next);
+    bumpHistory(this.store);
+    emit(this.store);
+    return clone(next);
+  }
+
+  deleteLabel(id: string): void {
+    const existing = this.getLabel(id);
+    if (existing.type === "system") throw badRequest("System labels cannot be deleted");
+    this.store.labels.delete(id);
+    for (const message of this.store.messages.values()) {
+      message.labelIds = message.labelIds.filter((labelId) => labelId !== id);
+    }
+    bumpHistory(this.store);
+    emit(this.store);
+  }
+
+  listMessages(options: GmailSearchOptions = {}): GmailListResponse<Pick<GmailMessage, "id" | "threadId">> {
+    const messages = this.visibleMessages(options).map((message) => ({ id: message.id, threadId: message.threadId }));
+    return { resultSizeEstimate: messages.length, messages };
+  }
+
+  getMessage(id: string): GmailMessage {
+    return clone(this.requireMessage(id));
+  }
+
+  insertMessage(input: Partial<GmailMessage> | GmailSendRequest): GmailMessage {
+    const message = this.buildMessage(input, {
+      labels: normalizeLabels((input as Partial<GmailMessage>).labelIds ?? ["INBOX", "UNREAD", "CATEGORY_PRIMARY"]),
+      threadId: (input as Partial<GmailMessage>).threadId,
+    });
+    this.store.messages.set(message.id, message);
+    emit(this.store);
+    return clone(message);
+  }
+
+  send(input: GmailSendRequest): GmailMessage {
+    const message = this.buildMessage(input, {
+      labels: ["SENT"],
+      threadId: input.message?.threadId,
+      fromCurrentUser: true,
+    });
+    this.store.messages.set(message.id, message);
+    emit(this.store);
+    return clone(message);
+  }
+
+  modifyMessage(id: string, request: GmailModifyRequest): GmailMessage {
+    const message = this.requireMessage(id);
+    message.labelIds = modifyLabels(message.labelIds, request);
+    message.historyId = bumpHistory(this.store);
+    emit(this.store);
+    return clone(message);
+  }
+
+  trashMessage(id: string): GmailMessage {
+    const message = this.requireMessage(id);
+    message.labelIds = modifyLabels(message.labelIds, { addLabelIds: ["TRASH"], removeLabelIds: ["INBOX", "SPAM"] });
+    message.historyId = bumpHistory(this.store);
+    emit(this.store);
+    return clone(message);
+  }
+
+  untrashMessage(id: string): GmailMessage {
+    const message = this.requireMessage(id);
+    message.labelIds = modifyLabels(message.labelIds, { addLabelIds: ["INBOX"], removeLabelIds: ["TRASH"] });
+    message.historyId = bumpHistory(this.store);
+    emit(this.store);
+    return clone(message);
+  }
+
+  deleteMessage(id: string): void {
+    this.requireMessage(id);
+    this.store.messages.delete(id);
+    for (const [draftId, draft] of this.store.drafts) {
+      if (draft.message.id === id) this.store.drafts.delete(draftId);
+    }
+    bumpHistory(this.store);
+    emit(this.store);
+  }
+
+  listThreads(options: GmailSearchOptions = {}): GmailListResponse<Pick<GmailThread, "id" | "historyId" | "snippet">> {
+    const threads = groupThreads(this.visibleMessages(options)).map((thread) => ({
+      id: thread.id,
+      historyId: thread.historyId,
+      snippet: thread.snippet,
+    }));
+    return { resultSizeEstimate: threads.length, threads };
+  }
+
+  getThread(id: string): GmailThread {
+    const messages = Array.from(this.store.messages.values())
+      .filter((message) => message.threadId === id)
+      .sort((a, b) => Number(a.internalDate) - Number(b.internalDate));
+    if (messages.length === 0) throw notFound(`Thread not found: ${id}`);
+    return clone(groupThreads(messages)[0]);
+  }
+
+  modifyThread(id: string, request: GmailModifyRequest): GmailThread {
+    const thread = this.getThread(id);
+    for (const message of thread.messages) {
+      this.modifyMessage(message.id, request);
+    }
+    return this.getThread(id);
+  }
+
+  trashThread(id: string): GmailThread {
+    const thread = this.getThread(id);
+    for (const message of thread.messages) this.trashMessage(message.id);
+    return this.getThread(id);
+  }
+
+  listDrafts(): GmailListResponse<Pick<GmailDraft, "id" | "message">> {
+    const drafts = Array.from(this.store.drafts.values()).map((draft) => ({ id: draft.id, message: clone(draft.message) }));
+    return { resultSizeEstimate: drafts.length, drafts };
+  }
+
+  getDraft(id: string): GmailDraft {
+    const draft = this.store.drafts.get(id);
+    if (!draft) throw notFound(`Draft not found: ${id}`);
+    return clone(draft);
+  }
+
+  createDraft(input: GmailSendRequest): GmailDraft {
+    const message = this.buildMessage(input, { labels: ["DRAFT"], threadId: input.message?.threadId, fromCurrentUser: true });
+    const draft: GmailDraft = { id: this.store.nextId("draft"), message };
+    this.store.drafts.set(draft.id, draft);
+    this.store.messages.set(message.id, message);
+    emit(this.store);
+    return clone(draft);
+  }
+
+  updateDraft(id: string, input: GmailSendRequest): GmailDraft {
+    const existing = this.getDraft(id);
+    const message = this.buildMessage(input, { labels: ["DRAFT"], threadId: input.message?.threadId ?? existing.message.threadId, fromCurrentUser: true, id: existing.message.id });
+    const draft = { id, message };
+    this.store.drafts.set(id, draft);
+    this.store.messages.set(message.id, message);
+    emit(this.store);
+    return clone(draft);
+  }
+
+  sendDraft(id: string): GmailMessage {
+    const draft = this.getDraft(id);
+    this.store.drafts.delete(id);
+    const message = { ...draft.message, labelIds: ["SENT"], historyId: bumpHistory(this.store), internalDate: String(this.store.now().getTime()) };
+    this.store.messages.set(message.id, message);
+    emit(this.store);
+    return clone(message);
+  }
+
+  deleteDraft(id: string): void {
+    const draft = this.getDraft(id);
+    this.store.drafts.delete(id);
+    this.store.messages.delete(draft.message.id);
+    bumpHistory(this.store);
+    emit(this.store);
+  }
+
+  private buildMessage(input: Partial<GmailMessage> | GmailSendRequest, options: { labels: string[]; threadId?: string; fromCurrentUser?: boolean; id?: string }): GmailMessage {
+    const now = this.store.now();
+    const user = this.currentUser();
+    const id = options.id ?? (input as Partial<GmailMessage>).id ?? this.store.nextId("msg");
+    const threadId = options.threadId ?? id;
+    const headers = buildHeaders(input, user.emailAddress, options.fromCurrentUser);
+    const bodyText = extractBody(input);
+    const payload: GmailMessagePart = (input as Partial<GmailMessage>).payload ?? {
+      partId: "",
+      mimeType: "text/plain",
+      filename: "",
+      headers,
+      body: {
+        size: bodyText.length,
+        data: encodeBase64Url(bodyText),
+      },
+      parts: ((input as GmailSendRequest).attachments ?? []).map((attachment, index) => ({
+        partId: String(index + 1),
+        mimeType: attachment.mimeType,
+        filename: attachment.filename,
+        headers: [
+          { name: "Content-Type", value: attachment.mimeType },
+          { name: "Content-Disposition", value: `attachment; filename="${attachment.filename}"` },
+        ],
+        body: { attachmentId: attachment.id, size: attachment.size, data: attachment.data },
+      })),
+    };
+    const message: GmailMessage = {
+      id,
+      threadId,
+      labelIds: normalizeLabels(options.labels),
+      snippet: makeSnippet(bodyText || headerValue(headers, "Subject")),
+      historyId: bumpHistory(this.store),
+      internalDate: (input as Partial<GmailMessage>).internalDate ?? String(now.getTime()),
+      payload,
+      sizeEstimate: (input as Partial<GmailMessage>).sizeEstimate ?? bodyText.length + JSON.stringify(headers).length,
+      raw: (input as GmailSendRequest).raw ?? (input as Partial<GmailMessage>).raw,
+      attachments: (input as GmailSendRequest).attachments ?? (input as Partial<GmailMessage>).attachments,
+    };
+    return message;
+  }
+
+  private visibleMessages(options: GmailSearchOptions): GmailMessage[] {
+    return Array.from(this.store.messages.values())
+      .filter((message) => options.includeSpamTrash || (!message.labelIds.includes("TRASH") && !message.labelIds.includes("SPAM")))
+      .filter((message) => !options.labelIds?.length || options.labelIds.every((labelId) => message.labelIds.includes(labelId)))
+      .filter((message) => matchesQuery(message, options.q))
+      .sort((a, b) => Number(b.internalDate) - Number(a.internalDate))
+      .slice(0, options.maxResults ?? undefined)
+      .map(clone);
+  }
+
+  private requireMessage(id: string): GmailMessage {
+    const message = this.store.messages.get(id);
+    if (!message) throw notFound(`Message not found: ${id}`);
+    return message;
+  }
+
+  private currentUser() {
+    const user = this.store.users.get(this.store.currentUserId);
+    if (!user) throw notFound(`User not found: ${this.store.currentUserId}`);
+    return user;
+  }
+}
+
+function normalizeLabels(labelIds: string[]): string[] {
+  return Array.from(new Set(labelIds));
+}
+
+function modifyLabels(current: string[], request: GmailModifyRequest): string[] {
+  const next = new Set(current);
+  for (const labelId of request.removeLabelIds ?? []) next.delete(labelId);
+  for (const labelId of request.addLabelIds ?? []) next.add(labelId);
+  return Array.from(next);
+}
+
+function groupThreads(messages: GmailMessage[]): GmailThread[] {
+  const byThread = new Map<string, GmailMessage[]>();
+  for (const message of messages) {
+    if (!byThread.has(message.threadId)) byThread.set(message.threadId, []);
+    byThread.get(message.threadId)!.push(message);
+  }
+  return Array.from(byThread.entries()).map(([id, threadMessages]) => {
+    const sorted = threadMessages.sort((a, b) => Number(a.internalDate) - Number(b.internalDate));
+    const latest = sorted[sorted.length - 1];
+    return {
+      id,
+      historyId: latest.historyId,
+      snippet: latest.snippet,
+      messages: sorted.map(clone),
+    };
+  });
+}
+
+function buildHeaders(input: Partial<GmailMessage> | GmailSendRequest, currentEmail: string, fromCurrentUser?: boolean): { name: string; value: string }[] {
+  const existing = (input as Partial<GmailMessage>).payload?.headers;
+  if (existing?.length) return existing.map(clone);
+  const send = input as GmailSendRequest;
+  return [
+    { name: "From", value: fromCurrentUser ? currentEmail : send.to?.[0] ?? "sender@example.com" },
+    { name: "To", value: send.to?.join(", ") ?? currentEmail },
+    ...(send.cc?.length ? [{ name: "Cc", value: send.cc.join(", ") }] : []),
+    { name: "Subject", value: send.subject ?? "(no subject)" },
+    { name: "Date", value: new Date().toUTCString() },
+  ];
+}
+
+function extractBody(input: Partial<GmailMessage> | GmailSendRequest): string {
+  const sendBody = (input as GmailSendRequest).body;
+  if (sendBody !== undefined) return sendBody;
+  const data = (input as Partial<GmailMessage>).payload?.body.data;
+  return data ? decodeBase64Url(data) : "";
+}
+
+function headerValue(headers: { name: string; value: string }[], name: string): string {
+  return headers.find((header) => header.name.toLowerCase() === name.toLowerCase())?.value ?? "";
+}
+
+function makeSnippet(value: string): string {
+  return value.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+
+function matchesQuery(message: GmailMessage, query?: string): boolean {
+  if (!query) return true;
+  const terms = query.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [];
+  return terms.every((term) => matchesTerm(message, term.replace(/^"|"$/g, "")));
+}
+
+function matchesTerm(message: GmailMessage, term: string): boolean {
+  const headers = message.payload.headers;
+  const lower = term.toLowerCase();
+  if (lower.startsWith("from:")) return headerValue(headers, "From").toLowerCase().includes(lower.slice(5));
+  if (lower.startsWith("to:")) return headerValue(headers, "To").toLowerCase().includes(lower.slice(3));
+  if (lower.startsWith("subject:")) return headerValue(headers, "Subject").toLowerCase().includes(lower.slice(8));
+  if (lower.startsWith("label:")) return message.labelIds.some((label) => label.toLowerCase() === lower.slice(6));
+  if (lower === "is:unread") return message.labelIds.includes("UNREAD");
+  if (lower === "is:read") return !message.labelIds.includes("UNREAD");
+  if (lower === "in:inbox") return message.labelIds.includes("INBOX");
+  if (lower === "in:sent") return message.labelIds.includes("SENT");
+  if (lower === "in:trash") return message.labelIds.includes("TRASH");
+  const haystack = [message.snippet, decodeBase64Url(message.payload.body.data ?? ""), ...headers.map((header) => header.value)].join(" ").toLowerCase();
+  return haystack.includes(lower);
+}
+
+export function encodeBase64Url(value: string): string {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+
+export function decodeBase64Url(value: string): string {
+  const padded = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}