1package view
2
3import (
4 "bytes"
5 "encoding/base64"
6 "fmt"
7 "image"
8 "image/png"
9 "io"
10 "mime/quotedprintable"
11 "net/http"
12 "os"
13 "regexp"
14 "strings"
15 "time"
16
17 _ "image/gif"
18 _ "image/jpeg"
19
20 "github.com/PuerkitoBio/goquery"
21 "github.com/charmbracelet/lipgloss"
22 "github.com/yuin/goldmark"
23 "github.com/yuin/goldmark/renderer/html"
24 "golang.org/x/sys/unix"
25)
26
27// getTerminalCellSize returns the height of a terminal cell in pixels.
28// It queries the terminal using TIOCGWINSZ to get both character and pixel dimensions.
29// Falls back to a default of 18 pixels if the query fails.
30func getTerminalCellSize() int {
31 const defaultCellHeight = 18
32
33 // Try stdout, stdin, stderr, then /dev/tty as last resort
34 fds := []int{int(os.Stdout.Fd()), int(os.Stdin.Fd()), int(os.Stderr.Fd())}
35
36 for _, fd := range fds {
37 if cellHeight := getCellHeightFromFd(fd); cellHeight > 0 {
38 return cellHeight
39 }
40 }
41
42 // Try /dev/tty directly - this works even when stdio is redirected (e.g., in Bubble Tea)
43 if tty, err := os.Open("/dev/tty"); err == nil {
44 defer tty.Close()
45 if cellHeight := getCellHeightFromFd(int(tty.Fd())); cellHeight > 0 {
46 return cellHeight
47 }
48 }
49
50 debugKitty("using default cell height: %d pixels", defaultCellHeight)
51 return defaultCellHeight
52}
53
54// getCellHeightFromFd attempts to get the terminal cell height from a file descriptor.
55// Returns 0 if it fails or if pixel dimensions are not available.
56func getCellHeightFromFd(fd int) int {
57 ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
58 if err != nil {
59 return 0
60 }
61
62 // ws.Row = number of character rows
63 // ws.Ypixel = height in pixels
64 // Some terminals don't report pixel dimensions (return 0)
65 if ws.Row > 0 && ws.Ypixel > 0 {
66 cellHeight := int(ws.Ypixel) / int(ws.Row)
67 if cellHeight > 0 {
68 debugKitty("terminal cell height: %d pixels (rows=%d, ypixel=%d, fd=%d)", cellHeight, ws.Row, ws.Ypixel, fd)
69 return cellHeight
70 }
71 }
72
73 // Terminal reported dimensions but no pixel info - this is common
74 if ws.Row > 0 && ws.Ypixel == 0 {
75 debugKitty("terminal fd=%d has rows=%d but no pixel info (ypixel=0)", fd, ws.Row)
76 }
77
78 return 0
79}
80
81// hyperlinkSupported checks if the terminal supports OSC 8 hyperlinks.
82func hyperlinkSupported() bool {
83 term := strings.ToLower(os.Getenv("TERM"))
84
85 // Terminals known to support OSC 8 hyperlinks
86 supportedTerms := []string{
87 "kitty",
88 "ghostty",
89 "wezterm",
90 "alacritty",
91 "foot",
92 "tmux",
93 "screen",
94 }
95
96 for _, supported := range supportedTerms {
97 if strings.Contains(term, supported) {
98 return true
99 }
100 }
101
102 // Check for specific terminal programs
103 termProgram := strings.ToLower(os.Getenv("TERM_PROGRAM"))
104 supportedPrograms := []string{
105 "iterm.app",
106 "hyper",
107 "vscode",
108 "ghostty",
109 "wezterm",
110 }
111
112 for _, supported := range supportedPrograms {
113 if strings.Contains(termProgram, supported) {
114 return true
115 }
116 }
117
118 // Check for VTE-based terminals (GNOME Terminal, etc.)
119 if os.Getenv("VTE_VERSION") != "" {
120 return true
121 }
122
123 // Check for specific environment variables that indicate hyperlink support
124 if os.Getenv("KITTY_WINDOW_ID") != "" ||
125 os.Getenv("GHOSTTY_RESOURCES_DIR") != "" ||
126 os.Getenv("WEZTERM_EXECUTABLE") != "" {
127 return true
128 }
129
130 return false
131}
132
133// hyperlink formats a string as either a terminal-clickable hyperlink or plain text with URL.
134func hyperlink(url, text string) string {
135 if text == "" {
136 text = url
137 }
138
139 supported := hyperlinkSupported()
140
141 if supported {
142 // Use OSC 8 hyperlink sequence for supported terminals
143 return fmt.Sprintf("\x1b]8;;%s\x07%s\x1b]8;;\x07", url, text)
144 } else {
145 // Fallback to plain text format for unsupported terminals
146 if text == url {
147 return fmt.Sprintf("<%s>", url)
148 }
149 return fmt.Sprintf("%s <%s>", text, url)
150 }
151}
152
153func decodeQuotedPrintable(s string) (string, error) {
154 reader := quotedprintable.NewReader(strings.NewReader(s))
155 body, err := io.ReadAll(reader)
156 if err != nil {
157 return "", err
158 }
159 return string(body), nil
160}
161
162// markdownToHTML converts a Markdown string to an HTML string.
163func markdownToHTML(md []byte) []byte {
164 var buf bytes.Buffer
165 p := goldmark.New(
166 goldmark.WithRendererOptions(
167 html.WithUnsafe(), // Allow raw HTML in email.
168 ),
169 )
170 if err := p.Convert(md, &buf); err != nil {
171 return md // Fallback to original markdown.
172 }
173 return buf.Bytes()
174}
175
176func kittySupported() bool {
177 term := strings.ToLower(os.Getenv("TERM"))
178 if strings.Contains(term, "kitty") {
179 return true
180 }
181 return os.Getenv("KITTY_WINDOW_ID") != ""
182}
183
184func debugKitty(format string, args ...interface{}) {
185 if os.Getenv("DEBUG_KITTY_IMAGES") == "" {
186 return
187 }
188 msg := fmt.Sprintf("[kitty-img] "+format+"\n", args...)
189 fmt.Print(msg)
190 if path := os.Getenv("DEBUG_KITTY_LOG"); path != "" {
191 if f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
192 _, _ = f.WriteString(msg)
193 _ = f.Close()
194 }
195 }
196}
197
198func fetchRemoteBase64(url string) string {
199 if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
200 return ""
201 }
202 client := &http.Client{Timeout: 5 * time.Second}
203 resp, err := client.Get(url)
204 if err != nil {
205 debugKitty("remote fetch failed url=%s err=%v", url, err)
206 return ""
207 }
208 defer resp.Body.Close()
209 if resp.StatusCode < 200 || resp.StatusCode >= 300 {
210 debugKitty("remote fetch non-200 url=%s status=%d", url, resp.StatusCode)
211 return ""
212 }
213 data, err := io.ReadAll(resp.Body)
214 if err != nil {
215 debugKitty("remote fetch read error url=%s err=%v", url, err)
216 return ""
217 }
218
219 img, _, err := image.Decode(bytes.NewReader(data))
220 if err != nil {
221 debugKitty("remote decode failed url=%s err=%v", url, err)
222 return ""
223 }
224
225 var buf bytes.Buffer
226 if err := png.Encode(&buf, img); err != nil {
227 debugKitty("remote png encode failed url=%s err=%v", url, err)
228 return ""
229 }
230
231 encoded := base64.StdEncoding.EncodeToString(buf.Bytes())
232 debugKitty("remote fetch ok url=%s len=%d", url, len(encoded))
233 return encoded
234}
235
236func dataURIBase64(uri string) string {
237 if !strings.HasPrefix(uri, "data:") {
238 return ""
239 }
240 comma := strings.Index(uri, ",")
241 if comma == -1 || comma+1 >= len(uri) {
242 return ""
243 }
244 return uri[comma+1:]
245}
246
247// imageRowPlaceholderPrefix is used to mark where image row spacing should be inserted.
248// This prevents the newline-collapsing regex from removing intentional spacing.
249// Uses brackets instead of angle brackets to avoid being interpreted as HTML tags.
250const imageRowPlaceholderPrefix = "[[MATCHA_IMG_ROWS:"
251const imageRowPlaceholderSuffix = "]]"
252
253func kittyInlineImage(payload string) string {
254 if payload == "" {
255 return ""
256 }
257
258 const chunkSize = 4096
259 var b strings.Builder
260
261 // Calculate how many terminal rows the image occupies to advance text after it.
262 rows := 1
263 if data, err := base64.StdEncoding.DecodeString(payload); err == nil {
264 if img, _, err := image.Decode(bytes.NewReader(data)); err == nil {
265 cellHeight := getTerminalCellSize()
266 h := img.Bounds().Dy()
267 rows = (h + cellHeight - 1) / cellHeight
268 if rows < 1 {
269 rows = 1
270 }
271 debugKitty("image height: %d pixels, cell height: %d pixels, rows needed: %d", h, cellHeight, rows)
272 }
273 }
274
275 for offset := 0; offset < len(payload); offset += chunkSize {
276 end := offset + chunkSize
277 if end > len(payload) {
278 end = len(payload)
279 }
280 more := "0"
281 if end < len(payload) {
282 more = "1"
283 }
284
285 chunk := payload[offset:end]
286 if offset == 0 {
287 // C=1 means cursor does NOT move after image render (stays at top-left of image position)
288 // This is needed for proper TUI rendering, but we must add newlines to push text below
289 b.WriteString(fmt.Sprintf("\x1b_Gf=100,a=T,q=2,C=1,m=%s;%s\x1b\\", more, chunk))
290 } else {
291 b.WriteString(fmt.Sprintf("\x1b_Gm=%s;%s\x1b\\", more, chunk))
292 }
293 }
294
295 // Add newlines to push cursor below the image.
296 // Use a placeholder that won't be collapsed by the newline regex.
297 b.WriteString(fmt.Sprintf("\n%s%d%s\n", imageRowPlaceholderPrefix, rows, imageRowPlaceholderSuffix))
298
299 return b.String()
300}
301
302// expandImageRowPlaceholders replaces image row placeholders with actual newlines.
303func expandImageRowPlaceholders(text string) string {
304 re := regexp.MustCompile(regexp.QuoteMeta(imageRowPlaceholderPrefix) + `(\d+)` + regexp.QuoteMeta(imageRowPlaceholderSuffix))
305 return re.ReplaceAllStringFunc(text, func(match string) string {
306 // Extract the number of rows from the placeholder
307 numStr := strings.TrimPrefix(match, imageRowPlaceholderPrefix)
308 numStr = strings.TrimSuffix(numStr, imageRowPlaceholderSuffix)
309 rows := 1
310 if _, err := fmt.Sscanf(numStr, "%d", &rows); err != nil || rows < 1 {
311 rows = 1
312 }
313 // Return the newlines needed to push content below the image
314 return strings.Repeat("\n", rows)
315 })
316}
317
318type InlineImage struct {
319 CID string
320 Base64 string
321}
322
323// ProcessBodyWithInline renders the body and resolves CID inline images when provided.
324func ProcessBodyWithInline(rawBody string, inline []InlineImage, h1Style, h2Style, bodyStyle lipgloss.Style) (string, error) {
325 inlineMap := make(map[string]string, len(inline))
326 for _, img := range inline {
327 cid := strings.TrimSpace(img.CID)
328 cid = strings.TrimPrefix(cid, "<")
329 cid = strings.TrimSuffix(cid, ">")
330 cid = strings.TrimPrefix(cid, "cid:")
331 if cid == "" || img.Base64 == "" {
332 continue
333 }
334 inlineMap[cid] = img.Base64
335 }
336 return processBody(rawBody, inlineMap, h1Style, h2Style, bodyStyle)
337}
338
339// ProcessBody takes a raw email body, decodes it, and formats it as plain
340// text with terminal hyperlinks.
341func ProcessBody(rawBody string, h1Style, h2Style, bodyStyle lipgloss.Style) (string, error) {
342 return processBody(rawBody, nil, h1Style, h2Style, bodyStyle)
343}
344
345func processBody(rawBody string, inline map[string]string, h1Style, h2Style, bodyStyle lipgloss.Style) (string, error) {
346 decodedBody, err := decodeQuotedPrintable(rawBody)
347 if err != nil {
348 decodedBody = rawBody
349 }
350
351 htmlBody := markdownToHTML([]byte(decodedBody))
352
353 doc, err := goquery.NewDocumentFromReader(bytes.NewReader(htmlBody))
354 if err != nil {
355 return "", fmt.Errorf("could not parse email body: %w", err)
356 }
357
358 doc.Find("style, script").Remove()
359
360 // Style headers by setting their text content.
361 // We use SetText so the h1/h2 tags remain in the document for spacing logic.
362 doc.Find("h1").Each(func(i int, s *goquery.Selection) {
363 s.SetText(h1Style.Render(s.Text()))
364 })
365
366 doc.Find("h2").Each(func(i int, s *goquery.Selection) {
367 s.SetText(h2Style.Render(s.Text()))
368 })
369
370 // Add newlines after block elements for better spacing.
371 doc.Find("p, div, h1, h2").Each(func(i int, s *goquery.Selection) {
372 s.After("\n\n")
373 })
374
375 // Replace <br> tags with newlines
376 doc.Find("br").Each(func(i int, s *goquery.Selection) {
377 s.ReplaceWithHtml("\n")
378 })
379
380 // Format links and images
381 doc.Find("a").Each(func(i int, s *goquery.Selection) {
382 href, exists := s.Attr("href")
383 if !exists {
384 return
385 }
386 s.ReplaceWithHtml(hyperlink(href, s.Text()))
387 })
388
389 doc.Find("img").Each(func(i int, s *goquery.Selection) {
390 src, exists := s.Attr("src")
391 if !exists {
392 return
393 }
394 alt, _ := s.Attr("alt")
395 if alt == "" {
396 alt = "Does not contain alt text"
397 }
398
399 if kittySupported() {
400 var payload string
401 if strings.HasPrefix(src, "data:image/") {
402 payload = dataURIBase64(src)
403 } else if strings.HasPrefix(src, "cid:") {
404 cid := strings.TrimPrefix(src, "cid:")
405 cid = strings.Trim(cid, "<>")
406 if inline != nil {
407 payload = inline[cid]
408 debugKitty("cid lookup for %s found=%t len=%d", cid, payload != "", len(payload))
409 } else {
410 debugKitty("cid lookup skipped inline map nil for %s", cid)
411 }
412 } else if strings.HasPrefix(src, "http://") || strings.HasPrefix(src, "https://") {
413 payload = fetchRemoteBase64(src)
414 }
415
416 if payload != "" {
417 if rendered := kittyInlineImage(payload); rendered != "" {
418 debugKitty("rendered inline image src=%s len=%d dataURI=%t cid=%t", src, len(payload), strings.HasPrefix(src, "data:"), strings.HasPrefix(src, "cid:"))
419 s.ReplaceWithHtml("\n" + rendered + "\n")
420 return
421 }
422 debugKitty("payload present but renderer returned empty src=%s len=%d", src, len(payload))
423 } else {
424 debugKitty("no payload for src=%s dataURI=%t cid=%t", src, strings.HasPrefix(src, "data:"), strings.HasPrefix(src, "cid:"))
425 }
426 } else {
427 debugKitty("kitty not detected for src=%s", src)
428 }
429 if hyperlinkSupported() {
430 s.ReplaceWithHtml(hyperlink(src, fmt.Sprintf("\n [Click here to view image: %s] \n", alt)))
431 } else {
432 s.ReplaceWithHtml(fmt.Sprintf("\n [Image: %s, %s] \n", alt, src))
433 }
434 })
435
436 text := doc.Text()
437
438 // Collapse excessive newlines, but not the image row placeholders
439 re := regexp.MustCompile(`\n{3,}`)
440 text = re.ReplaceAllString(text, "\n\n")
441
442 // Now expand the image row placeholders to actual newlines
443 text = expandImageRowPlaceholders(text)
444
445 return bodyStyle.Render(text), nil
446}