zele 0.3.17 → 0.3.20

package/src/gmail-client.ts

@@ -58,6 +58,7 @@ export interface ParsedMessage {
   inReplyTo?: string
   references?: string
   listUnsubscribe?: string
+  listUnsubscribePost?: string
   body: string // decoded body (html preferred for rich rendering)
   mimeType: string // 'text/plain' or 'text/html'
   textBody: string | null // decoded text/plain body when available (for reply parsing)
@@ -102,6 +103,7 @@ export interface ThreadListItem {
   inReplyTo: string | null
   hasAttachments: boolean
   listUnsubscribe: string | null
+  listUnsubscribePost: string | null
 }
 
 export interface ThreadListResult {
@@ -715,7 +717,7 @@ export class GmailClient {
     return res.data
   }
 
-  async getDraft({ draftId }: { draftId: string }): Promise<NotFoundError | AuthError | ApiError | { id: string; message: ParsedMessage; to: string[]; cc: string[]; bcc: string[] }> {
+  async getDraft({ draftId }: { draftId: string }): Promise<NotFoundError | AuthError | ApiError | { id: string; message: ParsedMessage; to: Sender[]; cc: Sender[]; bcc: Sender[] }> {
     const res = await gmailBoundary(this.account?.email ?? 'unknown', () =>
       withRetry(() =>
         this.gmail.users.drafts.get({
@@ -730,14 +732,13 @@ export class GmailClient {
     if (!res.data || !res.data.message) return new NotFoundError({ resource: `draft ${draftId}` })
 
     const message = this.parseMessage(res.data.message)
-    const headers = res.data.message.payload?.headers ?? []
 
     return {
       id: res.data.id ?? draftId,
       message,
-      to: this.getHeaderValues(headers, 'to'),
-      cc: this.getHeaderValues(headers, 'cc'),
-      bcc: this.getHeaderValues(headers, 'bcc'),
+      to: message.to,
+      cc: message.cc ?? [],
+      bcc: message.bcc,
     }
   }
 
@@ -816,6 +817,187 @@ export class GmailClient {
     )
   }
 
+  /**
+   * Update an existing draft. Gmail replaces the entire message content,
+   * so the caller must provide all fields (merge with existing draft before calling).
+   */
+  async updateDraft({
+    draftId,
+    to,
+    subject,
+    body,
+    cc,
+    bcc,
+    threadId,
+    fromEmail,
+    attachments,
+  }: {
+    draftId: string
+    to: Array<{ name?: string; email: string }>
+    subject: string
+    body: string
+    cc?: Array<{ name?: string; email: string }>
+    bcc?: Array<{ name?: string; email: string }>
+    threadId?: string
+    fromEmail?: string
+    attachments?: Array<{ filename: string; mimeType: string; content: Buffer }>
+  }) {
+    const raw = this.buildMimeMessage({ to, subject, body, cc, bcc, attachments, fromEmail })
+
+    const res = await gmailBoundary(this.account?.email ?? 'unknown', () =>
+      withRetry(() =>
+        this.gmail.users.drafts.update({
+          userId: 'me',
+          id: draftId,
+          requestBody: {
+            message: { raw, threadId },
+          },
+        }),
+      ),
+    )
+    if (res instanceof Error) return res
+
+    return res.data
+  }
+
+  /**
+   * Create a draft reply to a thread. Reuses the same reply-to resolution,
+   * reply-all CC computation, and In-Reply-To/References header logic as
+   * replyToThread(), but saves as a draft instead of sending.
+   */
+  async createDraftReply({
+    threadId,
+    body,
+    replyAll = false,
+    cc,
+    fromEmail,
+  }: {
+    threadId: string
+    body: string
+    replyAll?: boolean
+    cc?: Array<{ email: string }>
+    fromEmail?: string
+  }): Promise<EmptyThreadError | AuthError | ApiError | gmail_v1.Schema$Draft> {
+    const { parsed: thread } = await this.getThread({ threadId })
+    if (thread.messages.length === 0) {
+      return new EmptyThreadError({ threadId })
+    }
+
+    const lastMsg = thread.messages[thread.messages.length - 1]!
+
+    const replyTo = lastMsg.replyTo ?? lastMsg.from.email
+    const to = [{ email: replyTo }]
+
+    let resolvedCc: Array<{ email: string }> | undefined
+    if (replyAll) {
+      const profile = await this.getProfile()
+      if (profile instanceof Error) return profile
+      const myEmail = profile.emailAddress.toLowerCase()
+
+      const allRecipients = [
+        ...lastMsg.to.map((r) => r.email),
+        ...(lastMsg.cc?.map((r) => r.email) ?? []),
+      ]
+        .filter((e) => e.toLowerCase() !== myEmail)
+        .filter((e) => e.toLowerCase() !== replyTo.toLowerCase())
+
+      if (allRecipients.length > 0) {
+        resolvedCc = allRecipients.map((e) => ({ email: e }))
+      }
+    }
+
+    if (cc) {
+      resolvedCc = [...(resolvedCc ?? []), ...cc]
+    }
+
+    const refs = [lastMsg.references, lastMsg.messageId].filter(Boolean).join(' ')
+
+    const raw = this.buildMimeMessage({
+      to,
+      subject: lastMsg.subject.startsWith('Re:') ? lastMsg.subject : `Re: ${lastMsg.subject}`,
+      body,
+      cc: resolvedCc,
+      inReplyTo: lastMsg.messageId,
+      references: refs || undefined,
+      fromEmail,
+    })
+
+    const res = await gmailBoundary(this.account?.email ?? 'unknown', () =>
+      withRetry(() =>
+        this.gmail.users.drafts.create({
+          userId: 'me',
+          requestBody: {
+            message: { raw, threadId },
+          },
+        }),
+      ),
+    )
+    if (res instanceof Error) return res
+
+    return res.data
+  }
+
+  /**
+   * Create a draft forwarding a thread. Reuses the same forwarded-message body
+   * building logic as forwardThread(), but saves as a draft instead of sending.
+   */
+  async createDraftForward({
+    threadId,
+    to,
+    body,
+    fromEmail,
+  }: {
+    threadId: string
+    to: Array<{ email: string }>
+    body?: string
+    fromEmail?: string
+  }): Promise<EmptyThreadError | AuthError | ApiError | gmail_v1.Schema$Draft> {
+    const { parsed: thread } = await this.getThread({ threadId })
+    if (thread.messages.length === 0) {
+      return new EmptyThreadError({ threadId })
+    }
+
+    const lastMsg = thread.messages[thread.messages.length - 1]!
+    const renderedBody = renderEmailBody(lastMsg.body, lastMsg.mimeType)
+
+    const fromStr = lastMsg.from.name && lastMsg.from.name !== lastMsg.from.email
+      ? `${lastMsg.from.name} <${lastMsg.from.email}>`
+      : lastMsg.from.email
+
+    const fullBody = [
+      body ?? '',
+      '',
+      '---------- Forwarded message ----------',
+      `From: ${fromStr}`,
+      `Date: ${lastMsg.date}`,
+      `Subject: ${lastMsg.subject}`,
+      `To: ${lastMsg.to.map((t) => t.email).join(', ')}`,
+      '',
+      renderedBody,
+    ].join('\n')
+
+    const raw = this.buildMimeMessage({
+      to,
+      subject: `Fwd: ${lastMsg.subject}`,
+      body: fullBody,
+      fromEmail,
+    })
+
+    const res = await gmailBoundary(this.account?.email ?? 'unknown', () =>
+      withRetry(() =>
+        this.gmail.users.drafts.create({
+          userId: 'me',
+          requestBody: {
+            message: { raw, threadId },
+          },
+        }),
+      ),
+    )
+    if (res instanceof Error) return res
+
+    return res.data
+  }
+
   // =========================================================================
   // Label mutations (read/unread, star, archive, trash, labels)
   // =========================================================================
@@ -1332,6 +1514,7 @@ export class GmailClient {
       inReplyTo: getHeader('in-reply-to') ?? undefined,
       references: getHeader('references') ?? undefined,
       listUnsubscribe: getHeader('list-unsubscribe') ?? undefined,
+      listUnsubscribePost: getHeader('list-unsubscribe-post') ?? undefined,
       body,
       mimeType,
       textBody,
@@ -1397,8 +1580,11 @@ export class GmailClient {
     // Check if any message has attachments (non-inline)
     const hasAttachments = messages.some((m) => this.hasNonInlineAttachments(m.payload))
 
-    // List-Unsubscribe from latest message
+    // List-Unsubscribe / List-Unsubscribe-Post from latest message (RFC 2369 + RFC 8058).
+    // Used by `mail list` to surface can_unsubscribe / one_click booleans and
+    // by `mail unsubscribe` to plan the unsubscribe flow without re-fetching.
     const listUnsubscribe = getHeader('list-unsubscribe') ?? null
+    const listUnsubscribePost = getHeader('list-unsubscribe-post') ?? null
 
     return {
       id: raw.id ?? '',
@@ -1418,6 +1604,7 @@ export class GmailClient {
       inReplyTo,
       hasAttachments,
       listUnsubscribe,
+      listUnsubscribePost,
     }
   }
 

package/src/imap-smtp-client.ts

@@ -382,7 +382,11 @@ export class ImapSmtpClient {
               messageCount: 1,
               inReplyTo: env.inReplyTo ?? null,
               hasAttachments: this.hasAttachments(msg),
+              // IMAP list view uses envelope-only fetch, so raw headers aren't
+              // available. List-Unsubscribe stays null in list mode; it's
+              // resolved during getThread() where `source: true` is fetched.
               listUnsubscribe: null,
+              listUnsubscribePost: null,
             })
           }
         }
@@ -1086,9 +1090,9 @@ export class ImapSmtpClient {
     return {
       id: draftId,
       message: msg,
-      to: msg.to.map((t) => t.email),
-      cc: (msg.cc ?? []).map((c) => c.email),
-      bcc: msg.bcc.map((b) => b.email),
+      to: msg.to,
+      cc: msg.cc ?? [],
+      bcc: msg.bcc,
     }
   }
 
@@ -1097,11 +1101,11 @@ export class ImapSmtpClient {
     const draft = await this.getDraft({ draftId })
 
     const result = await this.sendMessage({
-      to: draft.to.map((email) => ({ email })),
+      to: draft.to,
       subject: draft.message.subject,
       body: draft.message.body,
-      cc: draft.cc.length > 0 ? draft.cc.map((email) => ({ email })) : undefined,
-      bcc: draft.bcc.length > 0 ? draft.bcc.map((email) => ({ email })) : undefined,
+      cc: draft.cc.length > 0 ? draft.cc : undefined,
+      bcc: draft.bcc.length > 0 ? draft.bcc : undefined,
     })
     if (result instanceof Error) return result
 
@@ -1124,6 +1128,168 @@ export class ImapSmtpClient {
     })
   }
 
+  /**
+   * Update an existing draft. IMAP has no native update — we delete the old
+   * draft and APPEND a new message to the Drafts folder.
+   */
+  async updateDraft({
+    draftId,
+    to,
+    subject,
+    body,
+    cc,
+    bcc,
+    fromEmail,
+  }: {
+    draftId: string
+    to: Array<{ name?: string; email: string }>
+    subject: string
+    body: string
+    cc?: Array<{ name?: string; email: string }>
+    bcc?: Array<{ name?: string; email: string }>
+    threadId?: string
+    fromEmail?: string
+    attachments?: Array<{ filename: string; mimeType: string; content: Buffer }>
+  }) {
+    // Delete old draft first — check for errors before creating replacement
+    const deleted = await this.deleteDraft({ draftId })
+    if (deleted instanceof Error) return deleted
+
+    // Create new draft with updated content
+    return this.createDraft({ to, subject, body, cc, bcc, fromEmail })
+  }
+
+  /**
+   * Create a draft reply to a thread. Resolves reply-to, reply-all CCs,
+   * and sets In-Reply-To/References headers, then appends to Drafts.
+   */
+  async createDraftReply({
+    threadId,
+    body,
+    replyAll = false,
+    cc,
+    fromEmail,
+  }: {
+    threadId: string
+    body: string
+    replyAll?: boolean
+    cc?: Array<{ email: string }>
+    fromEmail?: string
+  }): Promise<EmptyThreadError | AuthError | ApiError | { id: string; message: { id: string }; threadId: string }> {
+    const thread = await this.getThread({ threadId })
+    if (thread.parsed.messages.length === 0) {
+      return new EmptyThreadError({ threadId })
+    }
+
+    const lastMsg = thread.parsed.messages[thread.parsed.messages.length - 1]!
+    const replyTo = lastMsg.replyTo ?? lastMsg.from.email
+    const to = [{ email: replyTo }]
+
+    let resolvedCc: Array<{ email: string }> | undefined
+    if (replyAll) {
+      const myEmail = this.account.email.toLowerCase()
+      const allRecipients = [
+        ...lastMsg.to.map((r) => r.email),
+        ...(lastMsg.cc?.map((r) => r.email) ?? []),
+      ]
+        .filter((e) => e.toLowerCase() !== myEmail)
+        .filter((e) => e.toLowerCase() !== replyTo.toLowerCase())
+
+      if (allRecipients.length > 0) {
+        resolvedCc = allRecipients.map((e) => ({ email: e }))
+      }
+    }
+
+    if (cc) {
+      resolvedCc = [...(resolvedCc ?? []), ...cc]
+    }
+
+    const refs = [lastMsg.references, lastMsg.messageId].filter(Boolean).join(' ')
+    const subject = lastMsg.subject.startsWith('Re:') ? lastMsg.subject : `Re: ${lastMsg.subject}`
+
+    // Build MIME with reply headers
+    const headers = [
+      `From: ${fromEmail ?? this.account.email}`,
+      `To: ${to.map((r) => r.email).join(', ')}`,
+      `Subject: ${subject}`,
+      `Date: ${new Date().toUTCString()}`,
+      `MIME-Version: 1.0`,
+      `Content-Type: text/plain; charset=utf-8`,
+    ]
+    if (resolvedCc && resolvedCc.length > 0) {
+      headers.push(`Cc: ${resolvedCc.map((r) => r.email).join(', ')}`)
+    }
+    if (lastMsg.messageId) {
+      headers.push(`In-Reply-To: ${lastMsg.messageId}`)
+    }
+    if (refs) {
+      headers.push(`References: ${refs}`)
+    }
+
+    const raw = headers.join('\r\n') + '\r\n\r\n' + body
+    const rawBuffer = Buffer.from(raw)
+
+    const result = await this.withImap(async (client) => {
+      const draftsPath = await this.resolveMailboxPath(client, 'drafts')
+      const appendResult = await client.append(draftsPath, rawBuffer, ['\\Draft', '\\Seen'])
+      const uid = appendResult && typeof appendResult === 'object' && 'uid' in appendResult ? appendResult.uid : undefined
+      return {
+        id: uid ? makeThreadId(draftsPath, uid) : 'unknown',
+        message: { id: 'unknown' },
+        threadId: uid ? makeThreadId(draftsPath, uid) : 'unknown',
+      }
+    })
+    if (result instanceof Error) return result
+    return result
+  }
+
+  /**
+   * Create a draft forwarding a thread. Builds the forwarded-message body
+   * and appends to Drafts folder.
+   */
+  async createDraftForward({
+    threadId,
+    to,
+    body,
+    fromEmail,
+  }: {
+    threadId: string
+    to: Array<{ email: string }>
+    body?: string
+    fromEmail?: string
+  }): Promise<EmptyThreadError | AuthError | ApiError | { id: string; message: { id: string }; threadId: string }> {
+    const thread = await this.getThread({ threadId })
+    if (thread.parsed.messages.length === 0) {
+      return new EmptyThreadError({ threadId })
+    }
+
+    const lastMsg = thread.parsed.messages[thread.parsed.messages.length - 1]!
+    const renderedBody = renderEmailBody(lastMsg.body, lastMsg.mimeType)
+
+    const fromStr = lastMsg.from.name && lastMsg.from.name !== lastMsg.from.email
+      ? `${lastMsg.from.name} <${lastMsg.from.email}>`
+      : lastMsg.from.email
+
+    const fullBody = [
+      body ?? '',
+      '',
+      '---------- Forwarded message ----------',
+      `From: ${fromStr}`,
+      `Date: ${lastMsg.date}`,
+      `Subject: ${lastMsg.subject}`,
+      `To: ${lastMsg.to.map((t) => t.email).join(', ')}`,
+      '',
+      renderedBody,
+    ].join('\n')
+
+    return this.createDraft({
+      to,
+      subject: `Fwd: ${lastMsg.subject}`,
+      body: fullBody,
+      fromEmail,
+    })
+  }
+
   // =========================================================================
   // Folder listing (IMAP equivalent of labels)
   // =========================================================================
@@ -1207,6 +1373,8 @@ export class ImapSmtpClient {
     let body = ''
     let mimeType = 'text/plain'
     let textBody: string | null = null
+    let listUnsubscribe: string | undefined
+    let listUnsubscribePost: string | undefined
 
     if (msg.source) {
       const source = msg.source.toString('utf-8')
@@ -1214,6 +1382,16 @@ export class ImapSmtpClient {
       body = bodyResult.body
       mimeType = bodyResult.mimeType
       textBody = bodyResult.textBody
+
+      // Extract List-Unsubscribe / List-Unsubscribe-Post from raw MIME headers.
+      // envelope-based fetches don't surface these, but getThread always fetches
+      // source so it's available by the time we parse a full message.
+      const headerEnd = source.indexOf('\r\n\r\n')
+      const altEnd = source.indexOf('\n\n')
+      const headerSplit = headerEnd !== -1 ? headerEnd : altEnd
+      const headerText = headerSplit === -1 ? source : source.slice(0, headerSplit)
+      listUnsubscribe = this.getHeader(headerText, 'list-unsubscribe')
+      listUnsubscribePost = this.getHeader(headerText, 'list-unsubscribe-post')
     }
 
     // Extract attachments from bodyStructure
@@ -1240,7 +1418,8 @@ export class ImapSmtpClient {
       messageId: env.messageId ?? '',
       inReplyTo: env.inReplyTo,
       references: undefined,
-      listUnsubscribe: undefined,
+      listUnsubscribe,
+      listUnsubscribePost,
       body,
       mimeType,
       textBody,