From: Ben Burwell <ben@benburwell.com>
To: ~sircmpwn/aerc@lists.sr.ht
Cc: Ben Burwell <ben@benburwell.com>
Subject: [PATCH v2 2/5] Add maildir backend worker
Date: Thu, 11 Jul 2019 09:44:51 -0400
Message-Id: <20190711134454.80318-3-ben@benburwell.com>
In-Reply-To: <20190711134454.80318-1-ben@benburwell.com>
References: <20190711134454.80318-1-ben@benburwell.com>
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable

Add the initial implementation of a backend for Maildir accounts. Much
of the functionality required is implemented in the go-message and
go-maildir libraries, so we use them as much as possible.

The maildir worker hooks into a new maildir:// URL scheme in the
accounts.conf file which points to a container of several maildir
directories. From there, the OpenDirectory, FetchDirectoryContents, etc
messages work on subdirectories. This is implemented as a Container
struct which handles mapping between the symbolic email folder names and
UIDs to the concrete directories and file names.
---
From v1, I updated the MessageInfo method to return an error. In order
that a single malformed message not affect the ability to view all other
messages requested in the same FetchMessageHeaders message, I removed
the MessageInfos method from the Container struct. Now, each requested
message gets an independent response.

Also, the Configure procedure learns how to handle ~ home directories.

 go.mod                      |   1 +
 go.sum                      |   2 +
 worker/maildir/container.go | 105 +++++++++++
 worker/maildir/message.go   | 322 ++++++++++++++++++++++++++++++++
 worker/maildir/worker.go    | 353 ++++++++++++++++++++++++++++++++++++
 worker/worker.go            |   3 +
 6 files changed, 786 insertions(+)
 create mode 100644 worker/maildir/container.go
 create mode 100644 worker/maildir/message.go
 create mode 100644 worker/maildir/worker.go

diff --git a/go.mod b/go.mod
index 1c3d156..40c4df2 100644
--- a/go.mod
+++ b/go.mod
@@ -10,6 +10,7 @@ require (
 	github.com/ddevault/go-libvterm v0.0.0-20190526194226-b7d861da3810
 	github.com/emersion/go-imap v1.0.0-beta.6
 	github.com/emersion/go-imap-idle v0.0.0-20190519112320-2704abd7050e
+	github.com/emersion/go-maildir v0.0.0-20190505155239-cec913e0802c
 	github.com/emersion/go-message v0.10.3
 	github.com/emersion/go-sasl v0.0.0-20190520160400-47d427600317
 	github.com/emersion/go-smtp v0.11.1
diff --git a/go.sum b/go.sum
index 6c33d94..41b28a1 100644
--- a/go.sum
+++ b/go.sum
@@ -22,6 +22,8 @@ github.com/emersion/go-imap v1.0.0-beta.6 h1:x1Mco8GTkk=
w2+1/YHasok0pWrQLpgwJVG07
 github.com/emersion/go-imap v1.0.0-beta.6/go.mod h1:ORBuwFXdwt9QrAOecJPp=
irG6j9mao9wMfHIkd0EZfdo=3D
 github.com/emersion/go-imap-idle v0.0.0-20190519112320-2704abd7050e h1:L=
7bswVJZcf2YHofgom49oFRwVqmBj/qZqDy9/SJpZMY=3D
 github.com/emersion/go-imap-idle v0.0.0-20190519112320-2704abd7050e/go.m=
od h1:o14zPKCmEH5WC1vU5SdPoZGgNvQx7zzKSnxPQlobo78=3D
+github.com/emersion/go-maildir v0.0.0-20190505155239-cec913e0802c h1:Rx3=
zrFK2haYD5dHh2kF937k6psgyLB6u8GgLjdDv+hw=3D
+github.com/emersion/go-maildir v0.0.0-20190505155239-cec913e0802c/go.mod=
 h1:GnCg8DiGPgjPjAW4qqrCJDTHYflFCe5bvLE+lJ6TLwI=3D
 github.com/emersion/go-message v0.10.3 h1:4pajGb3Rq+gHLfRcWysgcwtGRNgLpB=
8LC6X/vRZ89d0=3D
 github.com/emersion/go-message v0.10.3/go.mod h1:3h+HsGTCFHmk4ngJ2IV/YPh=
dlaOcR6hcgqM3yca9v7c=3D
 github.com/emersion/go-sasl v0.0.0-20161116183048-7e096a0a6197 h1:rDJPby=
liyym8ZL/Wt71kdolp6yaD4fLIQz638E6JEt0=3D
diff --git a/worker/maildir/container.go b/worker/maildir/container.go
new file mode 100644
index 0000000..351afed
--- /dev/null
+++ b/worker/maildir/container.go
@@ -0,0 +1,105 @@
+package maildir
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"path/filepath"
+	"sort"
+
+	"github.com/emersion/go-maildir"
+
+	"git.sr.ht/~sircmpwn/aerc/lib/uidstore"
+)
+
+// A Container is a directory which contains other directories which adh=
ere to
+// the Maildir spec
+type Container struct {
+	dir  string
+	log  *log.Logger
+	uids *uidstore.Store
+}
+
+// NewContainer creates a new container at the specified directory
+// TODO: return an error if the provided directory is not accessible
+func NewContainer(dir string, l *log.Logger) *Container {
+	return &Container{dir: dir, uids: uidstore.NewStore(), log: l}
+}
+
+// ListFolders returns a list of maildir folders in the container
+func (c *Container) ListFolders() ([]string, error) {
+	files, err :=3D ioutil.ReadDir(c.dir)
+	if err !=3D nil {
+		return nil, fmt.Errorf("error reading folders: %v", err)
+	}
+	dirnames :=3D []string{}
+	for _, f :=3D range files {
+		if f.IsDir() {
+			dirnames =3D append(dirnames, f.Name())
+		}
+	}
+	return dirnames, nil
+}
+
+// OpenDirectory opens an existing maildir in the container by name, mov=
es new
+// messages into cur, and registers the new keys in the UIDStore.
+func (c *Container) OpenDirectory(name string) (maildir.Dir, error) {
+	dir :=3D c.Dir(name)
+	keys, err :=3D dir.Unseen()
+	if err !=3D nil {
+		return dir, err
+	}
+	for _, key :=3D range keys {
+		c.uids.GetOrInsert(key)
+	}
+	return dir, nil
+}
+
+// Dir returns a maildir.Dir with the specified name inside the containe=
r
+func (c *Container) Dir(name string) maildir.Dir {
+	return maildir.Dir(filepath.Join(c.dir, name))
+}
+
+// UIDs fetches the unique message identifiers for the maildir
+func (c *Container) UIDs(d maildir.Dir) ([]uint32, error) {
+	keys, err :=3D d.Keys()
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not get keys for %s: %v", d, err)
+	}
+	sort.Strings(keys)
+	var uids []uint32
+	for _, key :=3D range keys {
+		uids =3D append(uids, c.uids.GetOrInsert(key))
+	}
+	return uids, nil
+}
+
+// Message returns a Message struct for the given UID and maildir
+func (c *Container) Message(d maildir.Dir, uid uint32) (*Message, error)=
 {
+	if key, ok :=3D c.uids.GetKey(uid); ok {
+		return &Message{
+			dir: d,
+			uid: uid,
+			key: key,
+		}, nil
+	}
+	return nil, fmt.Errorf("could not find message with uid %d in maildir %=
s",
+		uid, d)
+}
+
+// DeleteAll deletes a set of messages by UID and returns the subset of =
UIDs
+// which were successfully deleted, stopping upon the first error.
+func (c *Container) DeleteAll(d maildir.Dir, uids []uint32) ([]uint32, e=
rror) {
+	var success []uint32
+	for _, uid :=3D range uids {
+		msg, err :=3D c.Message(d, uid)
+		if err !=3D nil {
+			return success, err
+		}
+		if err :=3D msg.Remove(); err !=3D nil {
+			return success, err
+		}
+		success =3D append(success, uid)
+	}
+	return success, nil
+}
diff --git a/worker/maildir/message.go b/worker/maildir/message.go
new file mode 100644
index 0000000..b95ec98
--- /dev/null
+++ b/worker/maildir/message.go
@@ -0,0 +1,322 @@
+package maildir
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/quotedprintable"
+	gomail "net/mail"
+	"strings"
+
+	"github.com/emersion/go-maildir"
+	"github.com/emersion/go-message"
+	_ "github.com/emersion/go-message/charset"
+	"github.com/emersion/go-message/mail"
+
+	"git.sr.ht/~sircmpwn/aerc/models"
+)
+
+// A Message is an individual email inside of a maildir.Dir.
+type Message struct {
+	dir maildir.Dir
+	uid uint32
+	key string
+}
+
+// NewReader reads a message into memory and returns an io.Reader for it=
.
+func (m Message) NewReader() (io.Reader, error) {
+	f, err :=3D m.dir.Open(m.key)
+	if err !=3D nil {
+		return nil, err
+	}
+	defer f.Close()
+	b, err :=3D ioutil.ReadAll(f)
+	if err !=3D nil {
+		return nil, err
+	}
+	return bytes.NewReader(b), nil
+}
+
+// Flags fetches the set of flags currently applied to the message.
+func (m Message) Flags() ([]maildir.Flag, error) {
+	return m.dir.Flags(m.key)
+}
+
+// SetFlags replaces the message's flags with a new set.
+func (m Message) SetFlags(flags []maildir.Flag) error {
+	return m.dir.SetFlags(m.key, flags)
+}
+
+// MarkRead either adds or removes the maildir.FlagSeen flag from the me=
ssage.
+func (m Message) MarkRead(seen bool) error {
+	flags, err :=3D m.Flags()
+	if err !=3D nil {
+		return fmt.Errorf("could not read previous flags: %v", err)
+	}
+	if seen {
+		flags =3D append(flags, maildir.FlagSeen)
+		return m.SetFlags(flags)
+	}
+	var newFlags []maildir.Flag
+	for _, flag :=3D range flags {
+		if flag !=3D maildir.FlagSeen {
+			newFlags =3D append(newFlags, flag)
+		}
+	}
+	return m.SetFlags(newFlags)
+}
+
+// Remove deletes the email immediately.
+func (m Message) Remove() error {
+	return m.dir.Remove(m.key)
+}
+
+// MessageInfo populates a models.MessageInfo struct for the message.
+func (m Message) MessageInfo() (*models.MessageInfo, error) {
+	f, err :=3D m.dir.Open(m.key)
+	if err !=3D nil {
+		return nil, err
+	}
+	defer f.Close()
+	msg, err :=3D message.Read(f)
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read message: %v", err)
+	}
+	bs, err :=3D parseEntityStructure(msg)
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not get structure: %v", err)
+	}
+	env, err :=3D parseEnvelope(&msg.Header)
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not get envelope: %v", err)
+	}
+	flags, err :=3D m.Flags()
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read flags: %v", err)
+	}
+	return &models.MessageInfo{
+		BodyStructure: bs,
+		Envelope:      env,
+		Flags:         translateFlags(flags),
+		InternalDate:  env.Date,
+		RFC822Headers: &mail.Header{msg.Header},
+		Size:          0,
+		Uid:           m.uid,
+	}, nil
+}
+
+// NewBodyPartReader creates a new io.Reader for the requested body part=
(s) of
+// the message.
+func (m Message) NewBodyPartReader(requestedParts []int) (io.Reader, err=
or) {
+	f, err :=3D m.dir.Open(m.key)
+	if err !=3D nil {
+		return nil, err
+	}
+	defer f.Close()
+	msg, err :=3D message.Read(f)
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read message: %v", err)
+	}
+	return fetchEntityPartReader(msg, requestedParts)
+}
+
+func fetchEntityPartReader(e *message.Entity, index []int) (io.Reader, e=
rror) {
+	if len(index) < 1 {
+		return nil, fmt.Errorf("no part to read")
+	}
+	if mpr :=3D e.MultipartReader(); mpr !=3D nil {
+		idx :=3D 0
+		for {
+			idx++
+			part, err :=3D mpr.NextPart()
+			if err !=3D nil {
+				return nil, err
+			}
+			if idx =3D=3D index[0] {
+				rest :=3D index[1:]
+				if len(rest) < 1 {
+					return fetchEntityReader(part)
+				}
+				return fetchEntityPartReader(part, index[1:])
+			}
+		}
+	}
+	if index[0] !=3D 1 {
+		return nil, fmt.Errorf("cannont return non-first part of non-multipart=
")
+	}
+	return fetchEntityReader(e)
+}
+
+// fetchEntityReader makes an io.Reader for the given entity. Since the
+// go-message package decodes the body for us, and the UI expects to dea=
l with
+// a reader whose bytes are encoded with the part's encoding, we are in =
the
+// interesting position of needing to re-encode the reader before sendin=
g it
+// off to the UI layer.
+//
+// TODO: probably change the UI to expect an already-decoded reader and =
decode
+// in the IMAP worker.
+func fetchEntityReader(e *message.Entity) (io.Reader, error) {
+	enc :=3D e.Header.Get("content-transfer-encoding")
+	var buf bytes.Buffer
+
+	// base64
+	if strings.EqualFold(enc, "base64") {
+		wc :=3D base64.NewEncoder(base64.StdEncoding, &buf)
+		defer wc.Close()
+		if _, err :=3D io.Copy(wc, e.Body); err !=3D nil {
+			return nil, fmt.Errorf("could not base64 encode: %v", err)
+		}
+		return &buf, nil
+	}
+
+	// quoted-printable
+	if strings.EqualFold(enc, "quoted-printable") {
+		wc :=3D quotedprintable.NewWriter(&buf)
+		defer wc.Close()
+		if _, err :=3D io.Copy(wc, e.Body); err !=3D nil {
+			return nil, fmt.Errorf("could not quoted-printable encode: %v", err)
+		}
+		return &buf, nil
+	}
+
+	// other general encoding
+	if _, err :=3D io.Copy(&buf, e.Body); err !=3D nil {
+		return nil, err
+	}
+
+	return &buf, nil
+}
+
+// split a MIME type into its major and minor parts
+func splitMIME(m string) (string, string) {
+	parts :=3D strings.Split(m, "/")
+	if len(parts) !=3D 2 {
+		return parts[0], ""
+	}
+	return parts[0], parts[1]
+}
+
+func parseEntityStructure(e *message.Entity) (*models.BodyStructure, err=
or) {
+	var body models.BodyStructure
+	contentType, ctParams, err :=3D e.Header.ContentType()
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not parse content type: %v", err)
+	}
+	mimeType, mimeSubType :=3D splitMIME(contentType)
+	body.MIMEType =3D mimeType
+	body.MIMESubType =3D mimeSubType
+	body.Params =3D ctParams
+	body.Description =3D e.Header.Get("content-description")
+	body.Encoding =3D e.Header.Get("content-transfer-encoding")
+	if cd :=3D e.Header.Get("content-disposition"); cd !=3D "" {
+		contentDisposition, cdParams, err :=3D e.Header.ContentDisposition()
+		if err !=3D nil {
+			return nil, fmt.Errorf("could not parse content disposition: %v", err=
)
+		}
+		body.Disposition =3D contentDisposition
+		body.DispositionParams =3D cdParams
+	}
+	body.Parts =3D []*models.BodyStructure{}
+	if mpr :=3D e.MultipartReader(); mpr !=3D nil {
+		for {
+			part, err :=3D mpr.NextPart()
+			if err =3D=3D io.EOF {
+				return &body, nil
+			} else if err !=3D nil {
+				return nil, err
+			}
+			ps, err :=3D parseEntityStructure(part)
+			if err !=3D nil {
+				return nil, fmt.Errorf("could not parse child entity structure: %v",=
 err)
+			}
+			body.Parts =3D append(body.Parts, ps)
+		}
+	}
+	return &body, nil
+}
+
+func parseEnvelope(h *message.Header) (*models.Envelope, error) {
+	date, err :=3D gomail.ParseDate(h.Get("date"))
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not parse date header: %v", err)
+	}
+	from, err :=3D parseAddressList(h, "from")
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read from address: %v", err)
+	}
+	to, err :=3D parseAddressList(h, "to")
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read to address: %v", err)
+	}
+	cc, err :=3D parseAddressList(h, "cc")
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read cc address: %v", err)
+	}
+	bcc, err :=3D parseAddressList(h, "bcc")
+	if err !=3D nil {
+		return nil, fmt.Errorf("could not read bcc address: %v", err)
+	}
+	return &models.Envelope{
+		Date:      date,
+		Subject:   h.Get("subject"),
+		MessageId: h.Get("message-id"),
+		From:      from,
+		To:        to,
+		Cc:        cc,
+		Bcc:       bcc,
+	}, nil
+}
+
+func parseAddressList(h *message.Header, key string) ([]*models.Address,=
 error) {
+	var converted []*models.Address
+	hdr :=3D h.Get(key)
+	if strings.TrimSpace(hdr) =3D=3D "" {
+		return converted, nil
+	}
+	addrs, err :=3D gomail.ParseAddressList(hdr)
+	if err !=3D nil {
+		if strings.Index(hdr, "@") < 0 {
+			return []*models.Address{&models.Address{
+				Name: hdr,
+			}}, nil
+		}
+		return nil, err
+	}
+	for _, addr :=3D range addrs {
+		parts :=3D strings.Split(addr.Address, "@")
+		var mbox, host string
+		if len(parts) > 1 {
+			mbox =3D strings.Join(parts[0:len(parts)-1], "@")
+			host =3D parts[len(parts)-1]
+		} else {
+			mbox =3D addr.Address
+		}
+		converted =3D append(converted, &models.Address{
+			Name:    addr.Name,
+			Mailbox: mbox,
+			Host:    host,
+		})
+	}
+	return converted, nil
+}
+
+var flagMap =3D map[maildir.Flag]models.Flag{
+	maildir.FlagReplied: models.AnsweredFlag,
+	maildir.FlagSeen:    models.SeenFlag,
+	maildir.FlagTrashed: models.DeletedFlag,
+	maildir.FlagFlagged: models.FlaggedFlag,
+	// maildir.FlagDraft Flag =3D 'D'
+	// maildir.FlagPassed Flag =3D 'P'
+}
+
+func translateFlags(maildirFlags []maildir.Flag) []models.Flag {
+	var flags []models.Flag
+	for _, maildirFlag :=3D range maildirFlags {
+		if flag, ok :=3D flagMap[maildirFlag]; ok {
+			flags =3D append(flags, flag)
+		}
+	}
+	return flags
+}
diff --git a/worker/maildir/worker.go b/worker/maildir/worker.go
new file mode 100644
index 0000000..f0c92ed
--- /dev/null
+++ b/worker/maildir/worker.go
@@ -0,0 +1,353 @@
+package maildir
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"github.com/emersion/go-maildir"
+
+	"git.sr.ht/~sircmpwn/aerc/models"
+	"git.sr.ht/~sircmpwn/aerc/worker/types"
+)
+
+var errUnsupported =3D fmt.Errorf("unsupported command")
+
+// A Worker handles interfacing between aerc's UI and a group of maildir=
s.
+type Worker struct {
+	c        *Container
+	selected *maildir.Dir
+	worker   *types.Worker
+}
+
+// NewWorker creates a new maildir worker with the provided worker.
+func NewWorker(worker *types.Worker) *Worker {
+	return &Worker{worker: worker}
+}
+
+// Run starts the worker's message handling loop.
+func (w *Worker) Run() {
+	for {
+		action :=3D <-w.worker.Actions
+		msg :=3D w.worker.ProcessAction(action)
+		if err :=3D w.handleMessage(msg); err =3D=3D errUnsupported {
+			w.worker.PostMessage(&types.Unsupported{
+				Message: types.RespondTo(msg),
+			}, nil)
+		} else if err !=3D nil {
+			w.worker.PostMessage(&types.Error{
+				Message: types.RespondTo(msg),
+				Error:   err,
+			}, nil)
+		}
+	}
+}
+
+func (w *Worker) done(msg types.WorkerMessage) {
+	w.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+}
+
+func (w *Worker) err(msg types.WorkerMessage, err error) {
+	w.worker.PostMessage(&types.Error{
+		Message: types.RespondTo(msg),
+		Error:   err,
+	}, nil)
+}
+
+func (w *Worker) handleMessage(msg types.WorkerMessage) error {
+	switch msg :=3D msg.(type) {
+	case *types.Unsupported:
+		// No-op
+	case *types.Configure:
+		return w.handleConfigure(msg)
+	case *types.Connect:
+		return w.handleConnect(msg)
+	case *types.ListDirectories:
+		return w.handleListDirectories(msg)
+	case *types.OpenDirectory:
+		return w.handleOpenDirectory(msg)
+	case *types.FetchDirectoryContents:
+		return w.handleFetchDirectoryContents(msg)
+	case *types.CreateDirectory:
+		return w.handleCreateDirectory(msg)
+	case *types.FetchMessageHeaders:
+		return w.handleFetchMessageHeaders(msg)
+	case *types.FetchMessageBodyPart:
+		return w.handleFetchMessageBodyPart(msg)
+	case *types.FetchFullMessages:
+		return w.handleFetchFullMessages(msg)
+	case *types.DeleteMessages:
+		return w.handleDeleteMessages(msg)
+	case *types.ReadMessages:
+		return w.handleReadMessages(msg)
+	case *types.CopyMessages:
+		return w.handleCopyMessages(msg)
+	case *types.AppendMessage:
+		return w.handleAppendMessage(msg)
+	case *types.SearchDirectory:
+		return w.handleSearchDirectory(msg)
+	}
+	return errUnsupported
+}
+
+func (w *Worker) handleConfigure(msg *types.Configure) error {
+	defer w.done(msg)
+	u, err :=3D url.Parse(msg.Config.Source)
+	if err !=3D nil {
+		w.worker.Logger.Printf("error configuring maildir worker: %v", err)
+		return err
+	}
+	dir :=3D u.Path
+	if u.Host =3D=3D "~" {
+		home, err :=3D os.UserHomeDir()
+		if err !=3D nil {
+			return fmt.Errorf("could not resolve home directory: %v", err)
+		}
+		dir =3D filepath.Join(home, u.Path)
+	}
+	w.c =3D NewContainer(dir, w.worker.Logger)
+	w.worker.Logger.Printf("configured base maildir: %s", dir)
+	return nil
+}
+
+func (w *Worker) handleConnect(msg *types.Connect) error {
+	w.done(msg)
+	return nil
+}
+
+func (w *Worker) handleListDirectories(msg *types.ListDirectories) error=
 {
+	defer w.done(msg)
+	dirs, err :=3D w.c.ListFolders()
+	if err !=3D nil {
+		w.worker.Logger.Printf("error listing directories: %v", err)
+		return err
+	}
+	for _, name :=3D range dirs {
+		w.worker.PostMessage(&types.Directory{
+			Message: types.RespondTo(msg),
+			Dir: &models.Directory{
+				Name:       name,
+				Attributes: []string{},
+			},
+		}, nil)
+	}
+	return nil
+}
+
+func (w *Worker) handleOpenDirectory(msg *types.OpenDirectory) error {
+	defer w.done(msg)
+	w.worker.Logger.Printf("opening %s", msg.Directory)
+	dir, err :=3D w.c.OpenDirectory(msg.Directory)
+	if err !=3D nil {
+		return err
+	}
+	w.selected =3D &dir
+	// TODO: why does this need to be sent twice??
+	info :=3D &types.DirectoryInfo{
+		Info: &models.DirectoryInfo{
+			Name:     msg.Directory,
+			Flags:    []string{},
+			ReadOnly: false,
+			// total messages
+			Exists: 0,
+			// new messages since mailbox was last opened
+			Recent: 0,
+			// total unread
+			Unseen: 0,
+		},
+	}
+	w.worker.PostMessage(info, nil)
+	w.worker.PostMessage(info, nil)
+	return nil
+}
+
+func (w *Worker) handleFetchDirectoryContents(
+	msg *types.FetchDirectoryContents) error {
+	defer w.done(msg)
+	uids, err :=3D w.c.UIDs(*w.selected)
+	if err !=3D nil {
+		w.worker.Logger.Printf("error scanning uids: %v", err)
+		return err
+	}
+	w.worker.PostMessage(&types.DirectoryContents{
+		Message: types.RespondTo(msg),
+		Uids:    uids,
+	}, nil)
+	return nil
+}
+
+func (w *Worker) handleCreateDirectory(msg *types.CreateDirectory) error=
 {
+	dir :=3D w.c.Dir(msg.Directory)
+	defer w.done(msg)
+	if err :=3D dir.Create(); err !=3D nil {
+		w.worker.Logger.Printf("could not create directory %s: %v",
+			msg.Directory, err)
+		return err
+	}
+	return nil
+}
+
+func (w *Worker) handleFetchMessageHeaders(
+	msg *types.FetchMessageHeaders) error {
+	defer w.done(msg)
+	for _, uid :=3D range msg.Uids {
+		m, err :=3D w.c.Message(*w.selected, uid)
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message: %v", err)
+			w.err(msg, err)
+			continue
+		}
+		info, err :=3D m.MessageInfo()
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message info: %v", err)
+			w.err(msg, err)
+			continue
+		}
+		w.worker.PostMessage(&types.MessageInfo{
+			Message: types.RespondTo(msg),
+			Info:    info,
+		}, nil)
+	}
+	return nil
+}
+
+func (w *Worker) handleFetchMessageBodyPart(
+	msg *types.FetchMessageBodyPart) error {
+	defer w.done(msg)
+
+	// get reader
+	m, err :=3D w.c.Message(*w.selected, msg.Uid)
+	if err !=3D nil {
+		w.worker.Logger.Printf("could not get message %d: %v", msg.Uid, err)
+		return err
+	}
+	r, err :=3D m.NewBodyPartReader(msg.Part)
+	if err !=3D nil {
+		w.worker.Logger.Printf(
+			"could not get body part reader for message=3D%d, parts=3D%#v: %v",
+			msg.Uid, msg.Part, err)
+		return err
+	}
+	w.worker.PostMessage(&types.MessageBodyPart{
+		Message: types.RespondTo(msg),
+		Part: &models.MessageBodyPart{
+			Reader: r,
+			Uid:    msg.Uid,
+		},
+	}, nil)
+
+	// mark message as read
+	if err :=3D m.MarkRead(true); err !=3D nil {
+		w.worker.Logger.Printf("could not mark message as read: %v", err)
+		return err
+	}
+
+	// send updated flags to ui
+	info, err :=3D m.MessageInfo()
+	if err !=3D nil {
+		w.worker.Logger.Printf("could not fetch message info: %v", err)
+		return err
+	}
+	w.worker.PostMessage(&types.MessageInfo{
+		Message: types.RespondTo(msg),
+		Info:    info,
+	}, nil)
+
+	return nil
+}
+
+func (w *Worker) handleFetchFullMessages(msg *types.FetchFullMessages) e=
rror {
+	defer w.done(msg)
+	for _, uid :=3D range msg.Uids {
+		m, err :=3D w.c.Message(*w.selected, uid)
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message %d: %v", uid, err)
+			return err
+		}
+		r, err :=3D m.NewReader()
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message reader: %v", err)
+			return err
+		}
+		w.worker.PostMessage(&types.FullMessage{
+			Message: types.RespondTo(msg),
+			Content: &models.FullMessage{
+				Uid:    uid,
+				Reader: r,
+			},
+		}, nil)
+	}
+	return nil
+}
+
+func (w *Worker) handleDeleteMessages(msg *types.DeleteMessages) error {
+	defer w.done(msg)
+	deleted, err :=3D w.c.DeleteAll(*w.selected, msg.Uids)
+	if len(deleted) > 0 {
+		w.worker.PostMessage(&types.MessagesDeleted{
+			Message: types.RespondTo(msg),
+			Uids:    deleted,
+		}, nil)
+	}
+	if err !=3D nil {
+		w.worker.Logger.Printf("error removing some messages: %v", err)
+		return err
+	}
+	return nil
+}
+
+func (w *Worker) handleReadMessages(msg *types.ReadMessages) error {
+	defer w.done(msg)
+	for _, uid :=3D range msg.Uids {
+		m, err :=3D w.c.Message(*w.selected, uid)
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message: %v", err)
+			w.err(msg, err)
+			continue
+		}
+		if err :=3D m.MarkRead(msg.Read); err !=3D nil {
+			w.worker.Logger.Printf("could not mark message as read: %v", err)
+			w.err(msg, err)
+			continue
+		}
+		info, err :=3D m.MessageInfo()
+		if err !=3D nil {
+			w.worker.Logger.Printf("could not get message info: %v", err)
+			w.err(msg, err)
+			continue
+		}
+		w.worker.PostMessage(&types.MessageInfo{
+			Message: types.RespondTo(msg),
+			Info:    info,
+		}, nil)
+	}
+	return nil
+}
+
+func (w *Worker) handleCopyMessages(msg *types.CopyMessages) error {
+	// TODO: this.
+	return nil
+}
+
+func (w *Worker) handleAppendMessage(msg *types.AppendMessage) error {
+	defer w.done(msg)
+	dest :=3D w.c.Dir(msg.Destination)
+	delivery, err :=3D dest.NewDelivery()
+	if err !=3D nil {
+		w.worker.Logger.Printf("could not deliver message to %s: %v",
+			msg.Destination, err)
+		return err
+	}
+	defer delivery.Close()
+	if _, err :=3D io.Copy(delivery, msg.Reader); err !=3D nil {
+		w.worker.Logger.Printf("could not write message to destination: %v", e=
rr)
+		return err
+	}
+	return nil
+}
+
+func (w *Worker) handleSearchDirectory(msg *types.SearchDirectory) error=
 {
+	return errUnsupported
+}
diff --git a/worker/worker.go b/worker/worker.go
index 7db7be5..dd14a23 100644
--- a/worker/worker.go
+++ b/worker/worker.go
@@ -2,6 +2,7 @@ package worker
=20
 import (
 	"git.sr.ht/~sircmpwn/aerc/worker/imap"
+	"git.sr.ht/~sircmpwn/aerc/worker/maildir"
 	"git.sr.ht/~sircmpwn/aerc/worker/types"
=20
 	"fmt"
@@ -27,6 +28,8 @@ func NewWorker(source string, logger *log.Logger) (*typ=
es.Worker, error) {
 		fallthrough
 	case "imaps":
 		worker.Backend =3D imap.NewIMAPWorker(worker)
+	case "maildir":
+		worker.Backend =3D maildir.NewWorker(worker)
 	default:
 		return nil, fmt.Errorf("Unknown backend %s", u.Scheme)
 	}
--=20
2.22.0