{sendersText}

58 | {numMessages > 1 && ( 59 | 60 | {numMessages} 61 | 62 | )} 63 | 64 | {dateString} 65 | 66 |

67 |

{subject ?? "(No subject)"}

68 |

{snippet}

69 |

70 |

71 | ); 72 | } 73 | -------------------------------------------------------------------------------- /electron/database/message.ts: -------------------------------------------------------------------------------- 1 | import { eq, sql } from "drizzle-orm"; 2 | 3 | import { EmailMessage } from "../gmail/types"; 4 | import { db } from "./db"; 5 | import { messageContents as messageContentsTable, messages as messagesTable } from "./schema"; 6 | 7 | export type Message = typeof messagesTable.$inferSelect; 8 | 9 | export function getAllMessages() { 10 | return db.select().from(messagesTable).all(); 11 | } 12 | 13 | export function getMostRecentMessage() { 14 | return db.query.messages.findFirst({ 15 | orderBy: sql`cast(${messagesTable.historyId} as integer) desc`, 16 | }); 17 | } 18 | 19 | function getLabels(labelIds: string[]) { 20 | return { 21 | isUnread: labelIds.includes("UNREAD"), 22 | }; 23 | } 24 | 25 | export function insertMessage(message: EmailMessage, threadId: number) { 26 | return db.transaction(async (tx) => { 27 | const insertedMessage = await db 28 | .insert(messagesTable) 29 | .values({ 30 | threadId, 31 | historyId: message.historyId, 32 | serverId: message.id, 33 | internalDate: message.internalDate, 34 | from: message.decodedPayload.headers["From"], 35 | to: message.decodedPayload.headers["To"], 36 | subject: message.decodedPayload.headers["Subject"], 37 | snippet: message.snippet, 38 | ...getLabels(message.labelIds ?? []), 39 | }) 40 | .returning({ id: messagesTable.id }); 41 | 42 | const messageId = insertedMessage[0]?.id; 43 | if (!messageId) { 44 | tx.rollback(); 45 | return; 46 | } 47 | 48 | await db.insert(messageContentsTable).values({ 49 | messageId, 50 | bodyHtml: message.decodedPayload.html, 51 | bodyText: message.decodedPayload.text, 52 | }); 53 | }); 54 | } 55 | 56 | export function updateMessageLabels(serverId: string, historyId: string, labelIds: string[]) { 57 | return db 58 | .update(messagesTable) 59 | .set({ historyId, ...getLabels(labelIds) }) 60 | .where(eq(messagesTable.serverId, serverId)); 61 | } 62 | 63 | export function addMessageLabels(serverId: string, historyId: string, labelIds: string[]) { 64 | const labels = getLabels(labelIds); 65 | 66 | const filteredLabels: Partial = {}; 67 | for (const [key, value] of Object.entries(labels)) { 68 | if (value) { 69 | filteredLabels[key as keyof typeof labels] = true; 70 | } 71 | } 72 | 73 | return db 74 | .update(messagesTable) 75 | .set({ historyId, ...filteredLabels }) 76 | .where(eq(messagesTable.serverId, serverId)); 77 | } 78 | 79 | export function removeMessageLabels(serverId: string, historyId: string, labelIds: string[]) { 80 | const labels = getLabels(labelIds); 81 | 82 | const filteredLabels: Partial = {}; 83 | for (const [key, value] of Object.entries(labels)) { 84 | if (!value) { 85 | filteredLabels[key as keyof typeof labels] = false; 86 | } 87 | } 88 | 89 | return db 90 | .update(messagesTable) 91 | .set({ historyId, ...filteredLabels }) 92 | .where(eq(messagesTable.serverId, serverId)); 93 | } 94 | -------------------------------------------------------------------------------- /electron/gmail/api.ts: -------------------------------------------------------------------------------- 1 | import { gmail_v1 } from "googleapis"; 2 | 3 | import { getGmailClient } from "./auth"; 4 | import { decodeEmailMessage, decodeEmailThread } from "./decoder"; 5 | import { EmailThread } from "./types"; 6 | 7 | export async function getThread(threadId: string) { 8 | const gmail = await getGmailClient(); 9 | return await gmail.users.threads 10 | .get({ 11 | id: threadId, 12 | userId: "me", 13 | format: "full", 14 | }) 15 | .then((res) => decodeEmailThread(res.data)) 16 | .catch((err) => { 17 | console.error("Failed to get thread", err); 18 | return null; 19 | }); 20 | } 21 | 22 | export async function getMessage(messageId: string) { 23 | const gmail = await getGmailClient(); 24 | return await gmail.users.messages 25 | .get({ 26 | id: messageId, 27 | userId: "me", 28 | format: "full", 29 | }) 30 | .then((res) => decodeEmailMessage(res.data)) 31 | .catch((err) => { 32 | console.error("Failed to get message", err); 33 | return null; 34 | }); 35 | } 36 | 37 | export async function listInboxThreads(maxThreads: number = 100): Promise { 38 | const gmail = await getGmailClient(); 39 | let nextPageToken: string | null = null; 40 | const threads: EmailThread[] = []; 41 | 42 | while (threads.length < maxThreads) { 43 | const res = await gmail.users.threads 44 | .list({ 45 | labelIds: ["INBOX"], 46 | pageToken: nextPageToken ?? undefined, 47 | maxResults: 20, 48 | userId: "me", 49 | }) 50 | .catch((err) => { 51 | console.error("Failed to list threads", err); 52 | return null; 53 | }); 54 | 55 | const resThreads = res?.data.threads ?? []; 56 | const decodedThreads = await Promise.all( 57 | resThreads.map(async (thread) => { 58 | if (thread.id) { 59 | return await getThread(thread.id); 60 | } 61 | }), 62 | ).then((threads) => threads.filter((thread): thread is EmailThread => thread !== undefined)); 63 | threads.push(...decodedThreads); 64 | 65 | nextPageToken = (res?.data.nextPageToken ?? null) as string | null; 66 | 67 | if (nextPageToken === null) { 68 | break; 69 | } 70 | } 71 | 72 | return threads; 73 | } 74 | 75 | export async function getUpdates(startHistoryId: string) { 76 | const gmail = await getGmailClient(); 77 | 78 | // TODO: only returns one page of updates 79 | const res = await gmail.users.history 80 | .list({ 81 | startHistoryId, 82 | userId: "me", 83 | }) 84 | .catch((err) => { 85 | console.error("Failed to get updates", err); 86 | return null; 87 | }); 88 | 89 | const history = res?.data.history ?? null; 90 | 91 | return history; 92 | } 93 | 94 | export async function modifyThread(id: string, options: gmail_v1.Schema$ModifyThreadRequest) { 95 | const gmail = await getGmailClient(); 96 | 97 | return await gmail.users.threads 98 | .modify({ 99 | id, 100 | userId: "me", 101 | requestBody: options, 102 | }) 103 | .then(() => getThread(id)) 104 | .catch((err) => { 105 | console.error("Failed to modify thread", err); 106 | return null; 107 | }); 108 | } 109 | -------------------------------------------------------------------------------- /electron/gmail/decoder.ts: -------------------------------------------------------------------------------- 1 | import { gmail_v1 } from "googleapis"; 2 | import { decode } from "html-entities"; 3 | 4 | import { DecodedPayload, EmailMessage, EmailThread } from "./types"; 5 | 6 | function decodeBase64(base64: string) { 7 | const text = atob(base64); 8 | const bytes = new Uint8Array(text.length); 9 | for (let i = 0; i < text.length; ++i) { 10 | bytes[i] = text.charCodeAt(i); 11 | } 12 | const decoder = new TextDecoder(); 13 | return decoder.decode(bytes); 14 | } 15 | 16 | function decodeBody(body: string) { 17 | // transform from other base64 variants 18 | const transformedBody = body.replaceAll("-", "+").replaceAll("_", "/"); 19 | try { 20 | return decodeBase64(transformedBody); 21 | } catch (err) { 22 | console.error(err); 23 | return null; 24 | } 25 | } 26 | 27 | function decodeHtmlEntities(str: string) { 28 | return decode(str); 29 | } 30 | 31 | function flattenParts( 32 | parts: gmail_v1.Schema$MessagePart[] | undefined, 33 | flattened: gmail_v1.Schema$MessagePart[], 34 | ) { 35 | if (parts === undefined) { 36 | return; 37 | } 38 | 39 | for (let i = 0; i < parts.length; ++i) { 40 | const part = parts[i]; 41 | if (!part) { 42 | continue; 43 | } 44 | 45 | if (part.parts) { 46 | flattenParts(part.parts, flattened); 47 | } else { 48 | flattened.push(part); 49 | } 50 | } 51 | } 52 | 53 | export function decodePayload(payload: gmail_v1.Schema$MessagePart) { 54 | const decodedPayload: DecodedPayload = { html: null, text: null, headers: {} }; 55 | payload.headers?.forEach(({ name, value }) => { 56 | if (!name || !value) { 57 | return; 58 | } 59 | decodedPayload.headers[name] = value; 60 | }); 61 | 62 | const flattened: gmail_v1.Schema$MessagePart[] = []; 63 | flattenParts([payload], flattened); 64 | 65 | const html = flattened.find((part) => part.mimeType === "text/html"); 66 | const text = flattened.find((part) => part.mimeType === "text/plain"); 67 | if (typeof html?.body?.data === "string") { 68 | const decodedHtml = decodeBody(html.body.data); 69 | decodedPayload.html = decodedHtml; 70 | } 71 | if (typeof text?.body?.data === "string") { 72 | const decodedText = decodeBody(text.body.data); 73 | decodedPayload.text = decodedText; 74 | } 75 | 76 | return decodedPayload; 77 | } 78 | 79 | export function decodeEmailMessage(message: gmail_v1.Schema$Message) { 80 | const { historyId, id, internalDate, labelIds, payload, snippet, threadId } = message; 81 | const decodedMessage: EmailMessage = { 82 | historyId: historyId ?? null, 83 | id: id ?? null, 84 | internalDate: internalDate ?? null, 85 | labelIds: labelIds ?? null, 86 | decodedPayload: payload ? decodePayload(payload) : { html: null, text: null, headers: {} }, 87 | snippet: snippet ? decodeHtmlEntities(snippet) : null, 88 | threadId: threadId ?? null, 89 | }; 90 | return decodedMessage; 91 | } 92 | 93 | export function decodeEmailThread(thread: gmail_v1.Schema$Thread) { 94 | const { historyId, id, messages } = thread; 95 | const decodedThread: EmailThread = { 96 | historyId: historyId ?? null, 97 | id: id ?? null, 98 | messages: messages?.map(decodeEmailMessage) ?? [], 99 | }; 100 | return decodedThread; 101 | } 102 | -------------------------------------------------------------------------------- /src/App.tsx: -------------------------------------------------------------------------------- 1 | import { useCallback, useEffect, useState } from "react"; 2 | import { Panel, PanelGroup, PanelResizeHandle } from "react-resizable-panels"; 3 | 4 | import { EmailThread } from "@/electron/gmail/types"; 5 | import { ThreadList } from "./components/thread-list"; 6 | import { ThreadView } from "./components/thread-view"; 7 | 8 | function App() { 9 | const [threads, setThreads] = useState(null); 10 | const [thread, setThread] = useState(null); 11 | 12 | const loadInbox = useCallback(async (abortSignal?: AbortSignal) => { 13 | const inbox = await window.gmail.listInbox(); 14 | if (!abortSignal?.aborted && inbox !== null) { 15 | setThreads(inbox); 16 | } 17 | }, []); 18 | 19 | // TODO: no abortsignal here 20 | const sync = useCallback(async () => { 21 | const didSync = await window.gmail.sync(); 22 | if (didSync) { 23 | loadInbox(); 24 | } 25 | }, [loadInbox]); 26 | 27 | useEffect(() => { 28 | const abortController = new AbortController(); 29 | 30 | loadInbox(abortController.signal); 31 | sync(); 32 | const syncInterval = setInterval(sync, 10 * 1000); 33 | 34 | return () => { 35 | abortController.abort(); 36 | clearInterval(syncInterval); 37 | }; 38 | }, [loadInbox, sync]); 39 | 40 | async function onThreadClick(threadId: string | null) { 41 | if (!threadId || thread?.id === threadId) { 42 | return; 43 | } 44 | 45 | // TODO: cache these retrieved threads? 46 | const fullThread = await window.gmail.getThread(threadId); 47 | 48 | const isUnread = fullThread?.messages.some((message) => message.labelIds?.includes("UNREAD")); 49 | if (!fullThread?.id || !isUnread) { 50 | setThread(fullThread); 51 | return; 52 | } 53 | 54 | const optimisticThread = { 55 | ...fullThread, 56 | messages: fullThread.messages.map((message) => ({ 57 | ...message, 58 | labelIds: message.labelIds?.filter((label) => label !== "UNREAD") ?? null, 59 | })), 60 | }; 61 | 62 | // TODO: make these sync automatically??? 63 | setThread(optimisticThread); 64 | setThreads( 65 | (threads) => 66 | threads?.map((t) => (t.id === optimisticThread.id ? optimisticThread : t)) ?? null, 67 | ); 68 | 69 | const updatedThread = await window.gmail.modifyThread(fullThread.id, { 70 | removeLabelIds: ["UNREAD"], 71 | }); 72 | const updatedOrFallbackThread = updatedThread ?? fullThread; 73 | 74 | setThread(updatedOrFallbackThread); 75 | setThreads( 76 | (threads) => 77 | threads?.map((t) => (t.id === updatedOrFallbackThread.id ? updatedOrFallbackThread : t)) ?? 78 | null, 79 | ); 80 | } 81 | 82 | return ( 83 |

84 | 85 | 86 | 91 | 92 | 93 |

94 | 95 | 96 | 97 | 98 | 99 |

100 | ); 101 | } 102 | 103 | export default App; 104 | -------------------------------------------------------------------------------- /src/components/email-message.tsx: -------------------------------------------------------------------------------- 1 | import DOMPurify from "dompurify"; 2 | import { useState } from "react"; 3 | import { twMerge } from "tailwind-merge"; 4 | 5 | import { EmailMessage as EmailMessageType } from "@/electron/gmail/types"; 6 | import { formatDate } from "@/utils/date"; 7 | import { convertTextToHtml } from "@/utils/email"; 8 | import { ContactItem } from "./contact-item"; 9 | 10 | type EmailMessageProps = { 11 | message: EmailMessageType; 12 | isCollapsible: boolean; 13 | }; 14 | 15 | export function EmailMessage({ message, isCollapsible }: EmailMessageProps) { 16 | const [isCollapsed, setIsCollapsed] = useState(isCollapsible); 17 | 18 | return ( 19 |

setIsCollapsed(false) : undefined} 22 | > 23 | setIsCollapsed(true) : undefined} 27 | /> 28 | 29 |

30 | ); 31 | } 32 | 33 | type EmailHeadersProps = { 34 | message: EmailMessageType; 35 | isCollapsed: boolean | null; 36 | onClick: (() => void) | undefined; 37 | }; 38 | 39 | function EmailHeaders({ message, isCollapsed, onClick }: EmailHeadersProps) { 40 | const headers = message.decodedPayload.headers; 41 | const from = headers["From"]; 42 | const to = headers["Delivered-To"] ?? headers["To"]; 43 | const cc = headers["Cc"]; 44 | const replyTo = headers["Reply-To"]; 45 | 46 | const date = message.internalDate ? new Date(parseInt(message.internalDate)) : null; 47 | const dateString = formatDate(date, { 48 | dateStyle: "relative", 49 | timeStyle: "short", 50 | relativeDateStyleFallback: "short", 51 | }); 52 | 53 | return ( 54 |

61 |

62 | {from && } 63 | {!isCollapsed && ( 64 | <> 65 | {to && } 66 | {cc && } 67 | {replyTo && } 68 | 69 | )} 70 |

71 |

{dateString}

72 |

73 | ); 74 | } 75 | 76 | type EmailPreviewProps = { 77 | message: EmailMessageType; 78 | isCollapsed: boolean; 79 | }; 80 | 81 | export function EmailPreview({ message, isCollapsed }: EmailPreviewProps) { 82 | const { html, text } = message.decodedPayload; 83 | const snippet = message.snippet; 84 | 85 | if (isCollapsed) { 86 | return

{snippet}

; 87 | } 88 | 89 | let htmlToRender: string | null = null; 90 | if (html !== null) { 91 | htmlToRender = html; 92 | } else if (text !== null) { 93 | htmlToRender = convertTextToHtml(text); 94 | } else { 95 | htmlToRender = "Email could not be decoded"; 96 | } 97 | 98 | return ( 99 |

104 | ); 105 | } 106 | -------------------------------------------------------------------------------- /src/components/thread-view.tsx: -------------------------------------------------------------------------------- 1 | import OpenAI from "openai"; 2 | import { useState } from "react"; 3 | import Markdown from "react-markdown"; 4 | 5 | import { EmailThread } from "@/electron/gmail/types"; 6 | import { summarizeThread } from "@/utils/openai"; 7 | import { EmailMessage } from "./email-message"; 8 | 9 | type ThreadViewProps = { 10 | thread: EmailThread | null; 11 | }; 12 | 13 | export function ThreadView({ thread }: ThreadViewProps) { 14 | const [summary, setSummary] = useState(null); 15 | const [isLoading, setIsLoading] = useState(false); 16 | 17 | if (!thread) { 18 | return ( 19 |

20 |

No email selected

21 |

22 | ); 23 | } 24 | 25 | const firstMessage = thread.messages.at(0); 26 | if (!firstMessage) { 27 | return ( 28 |

29 |

Empty email thread

30 |

31 | ); 32 | } 33 | 34 | const subject = firstMessage.decodedPayload.headers["Subject"]; 35 | 36 | return ( 37 |

38 |

{subject ?? "(No subject)"}

39 | { 43 | setIsLoading(true); 44 | const stream = await summarizeThread(thread).catch((err) => { 45 | if (err instanceof OpenAI.APIError) { 46 | setSummary(`OpenAI error: ${err.message}`); 47 | } else { 48 | setSummary(`Unexpected error: ${err}`); 49 | } 50 | return null; 51 | }); 52 | setIsLoading(false); 53 | 54 | if (stream !== null) { 55 | for await (const chunk of stream) { 56 | const content = chunk.choices[0]?.delta?.content ?? ""; 57 | setSummary((prev) => (prev ?? "") + content); 58 | } 59 | } 60 | }} 61 | /> 62 |

63 | {thread.messages?.map((message, i) => { 64 | const isLast = i === thread.messages.length - 1; 65 | return ; 66 | })} 67 |

68 |

69 | ); 70 | } 71 | 72 | type GenerationBannerProps = { 73 | summary: string | null; 74 | isLoading: boolean; 75 | onGenerate: () => void; 76 | }; 77 | 78 | function GenerationBanner({ summary, isLoading, onGenerate }: GenerationBannerProps) { 79 | return ( 80 |

81 | {isLoading && summary === null && ( 82 |

83 |

Generating...

84 |

85 |

86 |

87 |

88 |

89 |

90 | )} 91 | {!isLoading && summary === null && ( 92 |

93 |

Get an AI-powered summary of this email thread?

94 | 101 |

102 | )} 103 | {summary !== null && {summary}} 104 |

105 | ); 106 | } 107 | -------------------------------------------------------------------------------- /electron/gmail/client.ts: -------------------------------------------------------------------------------- 1 | import { gmail_v1 } from "googleapis"; 2 | 3 | import { getMostRecentMessage, insertMessage, updateMessageLabels } from "../database/message"; 4 | import { 5 | getAllThreads, 6 | getThreadByServerId, 7 | getThreadWithFullMessages, 8 | insertThread, 9 | updateThread, 10 | } from "../database/thread"; 11 | import * as api from "./api"; 12 | import { EmailThread } from "./types"; 13 | 14 | async function fullSync() { 15 | // TODO: make this a generator function 16 | const threads = await api.listInboxThreads(20); 17 | for (const thread of threads) { 18 | await insertThread(thread); 19 | } 20 | } 21 | 22 | async function partialSync(historyId: string) { 23 | const updates = await api.getUpdates(historyId); 24 | 25 | if (!updates) { 26 | return false; 27 | } 28 | 29 | for (const update of updates) { 30 | for (const messageAdded of update.messagesAdded ?? []) { 31 | const messageServerId = messageAdded.message?.id; 32 | const threadServerId = messageAdded.message?.threadId; 33 | if (!messageServerId || !threadServerId) { 34 | console.warn("New message has a null id or threadId"); 35 | continue; 36 | } 37 | 38 | const dbThread = await getThreadByServerId(threadServerId); 39 | if (!dbThread) { 40 | const gmailThread = await api.getThread(threadServerId); 41 | if (gmailThread) { 42 | await insertThread(gmailThread); 43 | } 44 | continue; 45 | } 46 | 47 | const message = await api.getMessage(messageServerId); 48 | if (!message) { 49 | console.error("Failed to get message", messageServerId); 50 | continue; 51 | } 52 | 53 | await insertMessage(message, dbThread.id); 54 | 55 | // TODO: hack to update thread historyId and latestMessageDate 56 | await updateThread({ 57 | id: threadServerId, 58 | historyId: message.historyId, 59 | messages: [message], 60 | }); 61 | } 62 | 63 | const labelUpdates = [...(update.labelsAdded ?? []), ...(update.labelsRemoved ?? [])]; 64 | for (const labelUpdate of labelUpdates) { 65 | const messageServerId = labelUpdate.message?.id; 66 | if (!messageServerId) { 67 | console.warn("New message has a null id"); 68 | continue; 69 | } 70 | 71 | const message = await api.getMessage(messageServerId); 72 | if (!message) { 73 | console.error("Failed to get message", messageServerId); 74 | continue; 75 | } 76 | 77 | if (!message.historyId) { 78 | console.warn("New message has a null historyId", messageServerId); 79 | continue; 80 | } 81 | 82 | await updateMessageLabels(messageServerId, message.historyId, message.labelIds ?? []); 83 | } 84 | } 85 | 86 | return true; 87 | } 88 | 89 | export async function sync(): Promise { 90 | // TODO: sync after returning original threads 91 | // TODO: use a different heuristic than the most recent message 92 | // this is fine for now because all our syncing operations are idempotent 93 | const mostRecentMessage = await getMostRecentMessage(); 94 | 95 | if (mostRecentMessage?.historyId) { 96 | return await partialSync(mostRecentMessage.historyId).catch((err) => { 97 | console.error("Partial sync failed", err); 98 | return false; 99 | }); 100 | } 101 | 102 | await fullSync().catch((err) => { 103 | console.error("Full sync failed", err); 104 | }); 105 | 106 | return true; 107 | } 108 | 109 | export async function listThreads(): Promise { 110 | const threads = await getAllThreads().catch((err) => { 111 | console.error("Failed to get all threads", err); 112 | return null; 113 | }); 114 | 115 | if (!threads) { 116 | return null; 117 | } 118 | 119 | const savedThreads: EmailThread[] = threads.map((thread) => ({ 120 | id: thread.serverId, 121 | historyId: thread.historyId, 122 | messages: thread.messages.map((message) => ({ 123 | id: message.serverId, 124 | historyId: message.historyId, 125 | internalDate: message.internalDate, 126 | labelIds: [message.isUnread && "UNREAD"].filter( 127 | (label): label is string => typeof label === "string", 128 | ), 129 | decodedPayload: { 130 | html: null, 131 | text: null, 132 | headers: { 133 | From: message.from, 134 | To: message.to, 135 | Subject: message.subject, 136 | }, 137 | }, 138 | snippet: message.snippet, 139 | threadId: thread.serverId, 140 | })), 141 | })); 142 | 143 | return savedThreads; 144 | } 145 | 146 | export async function getThread(threadId: string): Promise { 147 | const thread = await getThreadWithFullMessages(threadId).catch((err) => { 148 | console.error("Failed to get thread", err); 149 | return null; 150 | }); 151 | 152 | if (!thread) { 153 | return null; 154 | } 155 | 156 | // TODO: dedupe this code 157 | return { 158 | id: thread.serverId, 159 | historyId: thread.historyId, 160 | messages: thread.messages.map((message) => ({ 161 | id: message.serverId, 162 | historyId: message.historyId, 163 | internalDate: message.internalDate, 164 | labelIds: [message.isUnread && "UNREAD"].filter( 165 | (label): label is string => typeof label === "string", 166 | ), 167 | decodedPayload: { 168 | html: message.messageContents.bodyHtml, 169 | text: message.messageContents.bodyText, 170 | headers: { 171 | From: message.from, 172 | To: message.to, 173 | Subject: message.subject, 174 | }, 175 | }, 176 | snippet: message.snippet, 177 | threadId: thread.serverId, 178 | })), 179 | }; 180 | } 181 | 182 | export async function modifyThread(threadId: string, options: gmail_v1.Schema$ModifyThreadRequest) { 183 | const thread = await api.modifyThread(threadId, options).catch((err) => { 184 | console.error("Failed to modify thread", err); 185 | return null; 186 | }); 187 | 188 | if (!thread) { 189 | return null; 190 | } 191 | 192 | const isUpdated = await updateThread(thread) 193 | .then(() => true) 194 | .catch((err) => { 195 | console.error("Failed to update thread", err); 196 | return false; 197 | }); 198 | 199 | if (!isUpdated) { 200 | return null; 201 | } 202 | 203 | return thread; 204 | } 205 | --------------------------------------------------------------------------------