diff --git a/api/api.go b/api/api.go
index e6acbd1..16e6f2d 100644
--- a/api/api.go
+++ b/api/api.go
@@ -1,234 +1,234 @@
 package api
 
 import (
 	"fmt"
 	"path/filepath"
 
 	"github.com/atotto/clipboard"
 	"github.com/writeas/web-core/posts"
 	"github.com/writeas/writeas-cli/config"
 	"github.com/writeas/writeas-cli/fileutils"
 	"github.com/writeas/writeas-cli/log"
 	writeas "go.code.as/writeas.v2"
 	cli "gopkg.in/urfave/cli.v1"
 )
 
 func client(userAgent string, tor bool) *writeas.Client {
 	var client *writeas.Client
 	if tor {
 		client = writeas.NewTorClient(TorPort)
 	} else {
 		if config.IsDev() {
 			client = writeas.NewDevClient()
 		} else {
 			client = writeas.NewClient()
 		}
 	}
 	client.UserAgent = userAgent
 
 	return client
 }
 
 func NewClient(c *cli.Context, authRequired bool) (*writeas.Client, error) {
 	var client *writeas.Client
 	if config.IsTor(c) {
 		client = writeas.NewTorClient(TorPort)
 	} else {
 		if config.IsDev() {
 			client = writeas.NewDevClient()
 		} else {
 			client = writeas.NewClient()
 		}
 	}
 	client.UserAgent = config.UserAgent(c)
 	// TODO: load user into var shared across the app
 	u, _ := config.LoadUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if u != nil {
 		client.SetToken(u.AccessToken)
 	} else if authRequired {
 		return nil, fmt.Errorf("Not currently logged in. Authenticate with: writeas auth <username>")
 	}
 
 	return client, nil
 }
 
 // DoFetch retrieves the Write.as post with the given friendlyID,
 // optionally via the Tor hidden service.
 func DoFetch(friendlyID, ua string, tor bool) error {
 	cl := client(ua, tor)
 
 	p, err := cl.GetPost(friendlyID)
 	if err != nil {
 		return err
 	}
 
 	if p.Title != "" {
 		fmt.Printf("# %s\n\n", string(p.Title))
 	}
 	fmt.Printf("%s\n", string(p.Content))
 	return nil
 }
 
 // DoFetchPosts retrieves all remote posts for the
 // authenticated user
 func DoFetchPosts(c *cli.Context) ([]writeas.Post, error) {
 	cl, err := NewClient(c, true)
 	if err != nil {
 		return nil, err
 	}
 
 	posts, err := cl.GetUserPosts()
 	if err != nil {
 		return nil, err
 	}
 
 	return *posts, nil
 }
 
 // DoPost creates a Write.as post, returning an error if it was
 // unsuccessful.
 func DoPost(c *cli.Context, post []byte, font string, encrypt, tor, code bool) (*writeas.Post, error) {
 	cl, _ := NewClient(c, false)
 
 	pp := &writeas.PostParams{
 		Font:       config.GetFont(code, font),
 		Collection: config.Collection(c),
 	}
 	pp.Title, pp.Content = posts.ExtractTitle(string(post))
 	if lang := config.Language(c, true); lang != "" {
 		pp.Language = &lang
 	}
 	p, err := cl.CreatePost(pp)
 	if err != nil {
 		return nil, fmt.Errorf("Unable to post: %v", err)
 	}
 
 	var url string
 	if p.Collection != nil {
 		url = p.Collection.URL + p.Slug
 	} else {
 		if tor {
 			url = config.TorBaseURL
 		} else if config.IsDev() {
 			url = config.DevBaseURL
 		} else {
 			url = config.WriteasBaseURL
 		}
 		url += "/" + p.ID
 		// Output URL in requested format
 		if c.Bool("md") {
 			url += ".md"
 		}
 	}
 
 	if cl.Token() == "" {
 		// Store post locally, since we're not authenticated
 		AddPost(c, p.ID, p.Token)
 	}
 
 	// Copy URL to clipboard
 	err = clipboard.WriteAll(string(url))
 	if err != nil {
 		log.Errorln("writeas: Didn't copy to clipboard: %s", err)
 	} else {
 		log.Info(c, "Copied to clipboard.")
 	}
 
 	// Output URL
 	fmt.Printf("%s\n", url)
 
 	return p, nil
 }
 
 // DoUpdate updates the given post on Write.as.
 func DoUpdate(c *cli.Context, post []byte, friendlyID, token, font string, tor, code bool) error {
 	cl, _ := NewClient(c, false)
 
 	params := writeas.PostParams{}
 	params.Title, params.Content = posts.ExtractTitle(string(post))
 	if lang := config.Language(c, false); lang != "" {
 		params.Language = &lang
 	}
 	if code || font != "" {
 		params.Font = config.GetFont(code, font)
 	}
 
 	_, err := cl.UpdatePost(friendlyID, token, &params)
 	if err != nil {
 		if config.Debug() {
 			log.ErrorlnQuit("Problem updating: %v", err)
 		}
 		return fmt.Errorf("Post doesn't exist, or bad edit token given.")
 	}
 
 	if tor {
 		log.Info(c, "Post updated via hidden service.")
 	} else {
 		log.Info(c, "Post updated.")
 	}
 	return nil
 }
 
-// DoDelete deletes the given post on Write.as.
+// DoDelete deletes the given post on Write.as, and removes any local references
 func DoDelete(c *cli.Context, friendlyID, token string, tor bool) error {
 	cl, _ := NewClient(c, false)
 
 	err := cl.DeletePost(friendlyID, token)
 	if err != nil {
 		if config.Debug() {
 			log.ErrorlnQuit("Problem deleting: %v", err)
 		}
 		return fmt.Errorf("Post doesn't exist, or bad edit token given.")
 	}
 
 	if tor {
 		log.Info(c, "Post deleted from hidden service.")
 	} else {
 		log.Info(c, "Post deleted.")
 	}
 	removePost(c.App.ExtraInfo()["configDir"], friendlyID)
 
 	return nil
 }
 
 func DoLogIn(c *cli.Context, username, password string) error {
 	cl := client(config.UserAgent(c), config.IsTor(c))
 
 	u, err := cl.LogIn(username, password)
 	if err != nil {
 		if config.Debug() {
 			log.ErrorlnQuit("Problem logging in: %v", err)
 		}
 		return err
 	}
 
 	err = config.SaveUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]), u)
 	if err != nil {
 		return err
 	}
 	log.Info(c, "Logged in as %s.\n", u.User.Username)
 	return nil
 }
 
 func DoLogOut(c *cli.Context) error {
 	cl, err := NewClient(c, true)
 	if err != nil {
 		return err
 	}
 
 	err = cl.LogOut()
 	if err != nil {
 		if config.Debug() {
 			log.ErrorlnQuit("Problem logging out: %v", err)
 		}
 		return err
 	}
 
 	// Delete local user data
 	err = fileutils.DeleteFile(filepath.Join(config.UserDataDir(c.App.ExtraInfo()["configDir"]), config.UserFile))
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
diff --git a/commands/commands.go b/commands/commands.go
index 24de719..36eaa03 100644
--- a/commands/commands.go
+++ b/commands/commands.go
@@ -1,285 +1,285 @@
 package commands
 
 import (
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"text/tabwriter"
 
 	"github.com/howeyc/gopass"
 	"github.com/writeas/writeas-cli/api"
 	"github.com/writeas/writeas-cli/config"
 	"github.com/writeas/writeas-cli/fileutils"
 	"github.com/writeas/writeas-cli/log"
 	cli "gopkg.in/urfave/cli.v1"
 )
 
 func CmdPost(c *cli.Context) error {
 	_, err := api.HandlePost(api.ReadStdIn(), c)
 	return err
 }
 
 func CmdNew(c *cli.Context) error {
 	fname, p := api.ComposeNewPost()
 	if p == nil {
 		// Assume composeNewPost already told us what the error was. Abort now.
 		os.Exit(1)
 	}
 
 	// Ensure we have something to post
 	if len(*p) == 0 {
 		// Clean up temporary post
 		if fname != "" {
 			os.Remove(fname)
 		}
 
 		log.InfolnQuit("Empty post. Bye!")
 	}
 
 	_, err := api.HandlePost(*p, c)
 	if err != nil {
 		log.Errorln("Error posting: %s\n%s", err, config.MessageRetryCompose(fname))
 		return cli.NewExitError("", 1)
 	}
 
 	// Clean up temporary post
 	if fname != "" {
 		os.Remove(fname)
 	}
 
 	return nil
 }
 
 func CmdPublish(c *cli.Context) error {
 	filename := c.Args().Get(0)
 	if filename == "" {
 		return cli.NewExitError("usage: writeas publish <filename>", 1)
 	}
 	content, err := ioutil.ReadFile(filename)
 	if err != nil {
 		return err
 	}
 	p, err := api.HandlePost(content, c)
 	if err != nil {
 		return err
 	}
 
 	// Save post to posts folder
 	cfg, err := config.LoadConfig(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if cfg.Posts.Directory != "" {
 		err = api.WritePost(cfg.Posts.Directory, p)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
 func CmdDelete(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas delete <postId> [<token>]", 1)
 	}
 
 	u, _ := config.LoadUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if token == "" {
 		// Search for the token locally
 		token = api.TokenFromID(c, friendlyID)
 		if token == "" && u == nil {
 			log.Errorln("Couldn't find an edit token locally. Did you create this post here?")
 			log.ErrorlnQuit("If you have an edit token, use: writeas delete %s <token>", friendlyID)
 		}
 	}
 
 	tor := config.IsTor(c)
 	if c.Int("tor-port") != 0 {
 		api.TorPort = c.Int("tor-port")
 	}
 	if tor {
 		log.Info(c, "Deleting via hidden service...")
 	} else {
 		log.Info(c, "Deleting...")
 	}
 
 	err := api.DoDelete(c, friendlyID, token, tor)
 	if err != nil {
-		return err
+		log.ErrorlnQuit("Couldn't delete remote copy: %v", err)
 	}
 
 	// Delete local file, if necessary
 	cfg, err := config.LoadConfig(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if cfg.Posts.Directory != "" {
 		// TODO: handle deleting blog posts
 		err = fileutils.DeleteFile(filepath.Join(cfg.Posts.Directory, friendlyID+api.PostFileExt))
 		if err != nil {
-			return err
+			log.ErrorlnQuit("Couldn't delete local copy: %v", err)
 		}
 	}
 
 	return nil
 }
 
 func CmdUpdate(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas update <postId> [<token>]", 1)
 	}
 
 	u, _ := config.LoadUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if token == "" {
 		// Search for the token locally
 		token = api.TokenFromID(c, friendlyID)
 		if token == "" && u == nil {
 			log.Errorln("Couldn't find an edit token locally. Did you create this post here?")
 			log.ErrorlnQuit("If you have an edit token, use: writeas update %s <token>", friendlyID)
 		}
 	}
 
 	// Read post body
 	fullPost := api.ReadStdIn()
 
 	tor := config.IsTor(c)
 	if c.Int("tor-port") != 0 {
 		api.TorPort = c.Int("tor-port")
 	}
 	if tor {
 		log.Info(c, "Updating via hidden service...")
 	} else {
 		log.Info(c, "Updating...")
 	}
 
 	return api.DoUpdate(c, fullPost, friendlyID, token, c.String("font"), tor, c.Bool("code"))
 }
 
 func CmdGet(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas get <postId>", 1)
 	}
 
 	tor := config.IsTor(c)
 	if c.Int("tor-port") != 0 {
 		api.TorPort = c.Int("tor-port")
 	}
 	if tor {
 		log.Info(c, "Getting via hidden service...")
 	} else {
 		log.Info(c, "Getting...")
 	}
 
 	return api.DoFetch(friendlyID, config.UserAgent(c), tor)
 }
 
 func CmdAdd(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" || token == "" {
 		return cli.NewExitError("usage: writeas add <postId> <token>", 1)
 	}
 
 	err := api.AddPost(c, friendlyID, token)
 	return err
 }
 
 func CmdListPosts(c *cli.Context) error {
 	urls := c.Bool("url")
 	ids := c.Bool("id")
 
 	var p api.Post
 	posts := api.GetPosts(c)
 	tw := tabwriter.NewWriter(os.Stderr, 10, 0, 2, ' ', tabwriter.TabIndent)
 	numPosts := len(*posts)
 	if ids || !urls && numPosts != 0 {
 		fmt.Fprintf(tw, "Location\t%s\t%s\t\n", "ID", "Token")
 	} else if numPosts != 0 {
 		fmt.Fprintf(tw, "Location\t%s\t%s\t\n", "URL", "Token")
 	} else {
 		fmt.Fprintf(tw, "No local posts found\n")
 	}
 	for i := range *posts {
 		p = (*posts)[numPosts-1-i]
 		if ids || !urls {
 			fmt.Fprintf(tw, "local\t%s\t%s\t\n", p.ID, p.EditToken)
 		} else {
 			fmt.Fprintf(tw, "local\t%s\t%s\t\n", getPostURL(c, p.ID), p.EditToken)
 		}
 	}
 	u, _ := config.LoadUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if u != nil {
 		remotePosts, err := api.GetUserPosts(c)
 		if err != nil {
 			fmt.Println(err)
 		}
 
 		if len(remotePosts) > 0 {
 			identifier := "URL"
 			if ids || !urls {
 				identifier = "ID"
 			}
 			fmt.Fprintf(tw, "\nLocation\t%s\t%s\t\n", identifier, "Title")
 		}
 		for _, p := range remotePosts {
 			identifier := getPostURL(c, p.ID)
 			if ids || !urls {
 				identifier = p.ID
 			}
 
 			fmt.Fprintf(tw, "remote\t%s\t%s\t\n", identifier, p.Title)
 		}
 	}
 	return tw.Flush()
 }
 
 func getPostURL(c *cli.Context, slug string) string {
 	base := config.WriteasBaseURL
 	if config.IsDev() {
 		base = config.DevBaseURL
 	}
 	ext := ""
 	// Output URL in requested format
 	if c.Bool("md") {
 		ext = ".md"
 	}
 	return fmt.Sprintf("%s/%s%s", base, slug, ext)
 }
 
 func CmdAuth(c *cli.Context) error {
 	// Check configuration
 	u, err := config.LoadUser(config.UserDataDir(c.App.ExtraInfo()["configDir"]))
 	if err != nil {
 		return cli.NewExitError(fmt.Sprintf("couldn't load config: %v", err), 1)
 	}
 	if u != nil && u.AccessToken != "" {
 		return cli.NewExitError("You're already authenticated as "+u.User.Username+". Log out with: writeas logout", 1)
 	}
 
 	// Validate arguments and get password
 	username := c.Args().Get(0)
 	if username == "" {
 		return cli.NewExitError("usage: writeas auth <username>", 1)
 	}
 
 	fmt.Print("Password: ")
 	pass, err := gopass.GetPasswdMasked()
 	if err != nil {
 		return cli.NewExitError(fmt.Sprintf("error reading password: %v", err), 1)
 	}
 
 	// Validate password
 	if len(pass) == 0 {
 		return cli.NewExitError("Please enter your password.", 1)
 	}
 	err = api.DoLogIn(c, username, string(pass))
 	if err != nil {
 		return cli.NewExitError(fmt.Sprintf("error logging in: %v", err), 1)
 	}
 
 	return nil
 }
 
 func CmdLogOut(c *cli.Context) error {
 	return api.DoLogOut(c)
 }