Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556//! Parcel, a Gmail client for the Linux desktop.//!//! parcel opens each account's mail, else samples//! parcel login [gmail [NAME]] signs in to Gmail in the browser, as//! account NAME (Gmail when none is named)//! parcel login fastmail [NAME] signs in to Fastmail with an API token//! parcel login jmap NAME URL signs in to another JMAP server//! parcel --version prints the version it was built as
const std = @import("std");const build_options = @import("build_options");const siv = @import("siv");const zeit = @import("zeit");const Accounts = @import("Accounts.zig");const Compose = @import("Compose.zig");const Contacts = @import("Contacts.zig");const Desk = @import("Desk.zig");const Drafts = @import("Drafts.zig");const Http = @import("Http.zig");const Jmap = @import("Jmap.zig");const JmapSession = @import("JmapSession.zig");const LogFile = @import("LogFile.zig");const Mailbox = @import("Mailbox.zig");const Notifier = @import("Notifier.zig");const Session = @import("Session.zig");const Settings = @import("Settings.zig");const cache = @import("cache.zig");const oauth = @import("oauth.zig");const sample = @import("sample.zig");const linux = std.os.linux;const mem = std.mem;const posix = std.posix;const Io = std.Io;const testing = std.testing;const log = std.log.scoped(.parcel);
/// The Wayland app_id, and the name of the desktop file that goes with it.const app_id = "dev.rockorager.parcel";
/// The refresh token, in a Gmail account's directory, readable by the/// user alone.const token_file = "google-token";
/// What an account keeps in its directory, which parcel kept in the/// state directory itself before it had accounts.const account_files = [_][]const u8{ token_file, cache.file_name, "mail.json", Contacts.file_name, Drafts.file_name, Desk.filters_file,};
/// The account the one parcel had before becomes.const first_account = "Gmail";
pub const std_options: std.Options = .{ .logFn = logFn };
/// Where log lines are kept besides stderr, from when main opens it.var log_file: ?LogFile = null;
/// Writes each line to stderr in std's form, without its colors, and/// the lines worth keeping to the log file too, stamped. It touches/// neither the environment nor std's stderr lock, both of which a panic/// takes (LogFile.zig).fn logFn( comptime level: std.log.Level, comptime scope: @EnumLiteral(), comptime format: []const u8, args: anytype,) void { var buf: [4096]u8 = undefined; const line = LogFile.line(&buf, LogFile.now(), level, scope, format, args); LogFile.writeAll(posix.STDERR_FILENO, line[LogFile.stamp_len..]); if (comptime !LogFile.keeps(level, scope)) return; if (log_file) |*f| f.write(line);}
pub fn main(init: std.process.Init) !void { const args = try init.minimal.args.toSlice(init.arena.allocator()); // Before the state directory opens, so asking touches nothing. if (args.len == 2 and mem.eql(u8, args[1], "--version")) { return Io.File.stdout().writeStreamingAll(init.io, "parcel " ++ build_options.version ++ "\n"); } const settings = Settings.open(init.io, init.environ_map); defer if (settings) |s| s.close(); if (settings) |s| log_file = LogFile.open(s.dir.handle) catch |err| blk: { log.warn("{s}: {t}", .{ LogFile.name, err }); break :blk null; }; // Before the directory it is in closes. defer if (log_file) |*f| { f.close(); log_file = null; }; const arena = init.arena.allocator(); if (settings) |s| migrate(s, arena); if (args.len >= 2 and mem.eql(u8, args[1], "login")) return login(init, settings, args[2..]); if (args.len != 1) usage(init.io);
// Signed in, the window opens on each account's mail as last seen, // or none the first time, and its session brings it up to date; // otherwise it opens on the samples. const names = if (settings) |s| try s.accounts(arena) else &.{}; // Gmail's accounts sign in with it; JMAP's need none. const client = if (names.len > 0) try oauth.Client.load(arena, init.io, init.environ_map) else null; if (names.len > Desk.max_accounts) { log.err("{d} accounts; parcel shows the first {d}", .{ names.len, Desk.max_accounts }); }
const app = try siv.appCreate(.{ .name = "Parcel", .app_id = app_id }); defer siv.appDestroy(app); // Parcel says everything else in English, so its dates do too, not in // the locale's language, until it is translated. try siv.appSetLanguage(app, "en", .ltr); // The terminal's face, as Fontconfig's monospace names it; Omarchy // sets that to the font it gives every terminal. try siv.appSetDefaultFont(app, "monospace"); var run: Run = .{ .init = init, .app = app, .settings = settings, .client = client, .names = if (names.len == 0) &.{""} else names[0..@min(names.len, Desk.max_accounts)], .downloads = downloads(arena, init.environ_map), .avatars = avatars(arena, init.environ_map), .window = .null, .accounts = null, .samples = undefined, }; defer run.close(); // One parcel runs: launching another, or clicking a notification, // comes to it. try siv.appLaunch(app, .{ .on_activate = Run.onActivate, .user_data = &run }); quitOnSignal(app) catch |err| log.warn("watching for signals: {t}", .{err}); // Logging out can take the compositor away first; what the sessions // hold is saved then too. siv.appRun(app) catch |err| log.err("running: {t}", .{err}); if (run.accounts) |accounts| for (accounts.list) |a| { if (a.session) |s| s.finish(); if (a.jmap) |j| j.finish(); };}
/// The pipe a signal's handler writes to and siv's loop reads, and the/// app it quits.var quit_pipe: [2]linux.fd_t = .{ -1, -1 };var quit_app: siv.App = .null;
/// Ends the run on SIGTERM (logging out, shutting down), SIGINT, and/// SIGHUP the way closing the window does, so the sessions send what is/// queued and save the mail. The handler only writes to a pipe siv/// watches; blocking the signals for a signalfd instead would leave them/// blocked in the programs parcel starts, which inherit the mask.fn quitOnSignal(app: siv.App) !void { switch (linux.errno(linux.pipe2(&quit_pipe, .{ .NONBLOCK = true, .CLOEXEC = true }))) { .SUCCESS => {}, else => |err| return posix.unexpectedErrno(err), } quit_app = app; _ = try siv.appWatchFd(app, quit_pipe[0], .{ .readable = true }, onQuit, null, null); const action: posix.Sigaction = .{ .handler = .{ .handler = onSignal }, .mask = posix.sigemptyset(), .flags = posix.SA.RESTART, }; for ([_]posix.SIG{ .TERM, .INT, .HUP }) |sig| posix.sigaction(sig, &action, null);}
fn onSignal(_: posix.SIG) callconv(.c) void { const byte: u8 = 0; _ = linux.write(quit_pipe[1], @ptrCast(&byte), 1);}
fn onQuit(_: ?*anyopaque, _: siv.Watch, _: siv.WatchFlags) callconv(.c) void { var buf: [16]u8 = undefined; while (true) { const n = linux.read(quit_pipe[0], &buf, buf.len); if (linux.errno(n) != .SUCCESS or n == 0) break; } siv.appQuit(quit_app) catch |err| log.err("quitting: {t}", .{err});}
fn usage(io: Io) noreturn { say("usage: parcel [--version | login [gmail [NAME] | fastmail [NAME] | jmap NAME URL]]\n", io, .{}); std.process.exit(2);}
/// Moves the one account parcel had before it had several, kept in the/// state directory itself, to its own directory as the first account.fn migrate(settings: Settings, arena: mem.Allocator) void { settings.dir.access(settings.io, token_file, .{}) catch return; const names = settings.accounts(arena) catch |err| return log.warn("listing the accounts: {t}", .{err}); if (names.len > 0) return; settings.moveTo(first_account, &account_files) catch |err| { return log.warn("moving the account to {s}/{s}: {t}", .{ Settings.accounts_dir, first_account, err }); }; log.info("the account is now {s}/{s}; rename its directory to rename it", .{ Settings.accounts_dir, first_account, });}
/// The window and what drives it, made at the first activation, as siv's/// single instance wants; a later one shows the window again.const Run = struct { init: std.process.Init, app: siv.App, settings: ?Settings, /// What Gmail's accounts sign in with, if parcel has one. client: ?oauth.Client, /// The accounts to open, or one with no name for the samples. names: []const []const u8, downloads: []const u8, /// Where senders' photos from Gravatar are kept. avatars: []const u8, window: siv.Window, accounts: ?*Accounts, samples: Samples,
fn onActivate(user_data: ?*anyopaque, _: siv.App, activation: *const siv.Activation) callconv(.c) void { const self: *Run = @ptrCast(@alignCast(user_data)); const first = self.accounts == null; if (first) self.open() catch |err| { log.err("opening the window: {t}", .{err}); siv.appQuit(self.app) catch |e| log.err("quitting: {t}", .{e}); return; }; const token = if (activation.activation_token) |p| p[0..activation.activation_token_len] else ""; // A window just opened shows by itself; one open already, as a // notification's click or a second launch finds it, is brought up. if (first and token.len == 0) return; Notifier.activate(self.window, token); }
/// What it makes, `close` takes down, however far it got. The mail /// loads here, not before, so a launch that only shows the running /// parcel reads none. fn open(self: *Run) !void { const init = self.init; self.window = try siv.windowCreate(self.app, .{ .title = "Parcel", .app_id = app_id, .width = 1200, .height = 760, // Narrower, the list's names and chips crowd out the subject. .min_width = 640, .min_height = 420, }); const accounts = try Accounts.create(init.gpa, init.io, self.window, self.names, self.settings); self.accounts = accounts; const now = Io.Timestamp.now(init.io, .real).toSeconds(); const samples = self.names.len == 1 and self.names[0].len == 0; if (samples) { log.info("showing sample mail; `parcel login` signs in to Gmail", .{}); try sample.load(&accounts.list[0].mail, now); } else for (accounts.list) |*a| { const s = a.settings orelse continue; const cached = cache.load(init.gpa, s) orelse continue; a.mail.deinit(); a.mail = cached; } var zones: [Desk.max_accounts]zeit.TimeZone = undefined; for (zones[0..accounts.list.len]) |*zone| zone.* = zeit.local(init.gpa, init.io, .{ .tz = init.environ_map.get("TZ"), .tzdir = init.environ_map.get("TZDIR"), }) catch |err| zone: { log.warn("reading the local time zone: {t}; dates are in UTC", .{err}); break :zone zeit.utc; }; try accounts.build(zones[0..accounts.list.len]); for (accounts.list) |a| { a.desk.?.messages.downloads = self.downloads; a.desk.?.messages.avatars.dir = self.avatars; } if (samples) return self.openSamples(accounts.list[0].desk.?, now); for (accounts.list) |*a| try self.startSession(a); }
/// Starts an account's session, Gmail's or a JMAP server's, if it is /// signed in. fn startSession(self: *Run, a: *Accounts.Account) !void { const s = a.settings orelse return; var token_buf: [1024]u8 = undefined; defer std.crypto.secureZero(u8, &token_buf); const desk = a.desk.?; const account: Notifier.Account = .{ .name = if (self.names.len > 1) a.name else "", .index = a.index }; if (s.load(JmapSession.token_file, &token_buf)) |token| { desk.compose.contacts.load(s); var url_buf: [1024]u8 = undefined; const url = if (s.load(JmapSession.url_file, &url_buf)) |u| mem.trim(u8, u, " \n") else Jmap.fastmail; const t = mem.trim(u8, token, " \n"); a.jmap = try JmapSession.start(self.init.gpa, self.init.io, self.app, desk, s, url, t, account); return; } const token = s.load(token_file, &token_buf) orelse { return log.warn("{s} is not signed in: `parcel login gmail {s}`", .{ a.name, a.name }); }; const client = self.client orelse { return log.warn("{s} needs Google's OAuth client: see `parcel login`", .{a.name}); }; desk.compose.contacts.load(s); const refresh = mem.trim(u8, token, " \n"); a.session = try Session.start(self.init.gpa, self.init.io, self.app, desk, s, client, refresh, account); }
fn openSamples(self: *Run, desk: *Desk, now: i64) !void { self.samples = .{ .desk = desk }; desk.messages.fetcher = .{ .context = &self.samples, .fetch = Samples.fetch, .attachment = null, .web = null, }; desk.compose.keeper = .{ .context = &self.samples, .save = Samples.save, .send = Samples.send, .discard = Samples.discard, }; try sample.people(&desk.compose.contacts, now); }
fn close(self: *Run) void { const accounts = self.accounts orelse { if (self.window != .null) siv.windowDestroy(self.window); return; }; for (accounts.list) |*a| { if (a.session) |s| s.destroy(); if (a.jmap) |j| j.destroy(); a.session = null; a.jmap = null; } // The window's handlers hold the desks, so the window goes first. siv.windowDestroy(self.window); accounts.destroy(); }};
/// Answers the reader with made-up messages when there is no Gmail.const Samples = struct { desk: *Desk,
fn fetch(context: *anyopaque, thread: []const u8) void { const self: *Samples = @ptrCast(@alignCast(context)); var arena_state: std.heap.ArenaAllocator = .init(self.desk.gpa); defer arena_state.deinit(); const id = self.desk.mail.findThread(thread) orelse return; const messages = sample.conversation(arena_state.allocator(), self.desk.mail.get(id)) catch null; self.desk.messages.deliver(thread, messages) catch |err| log.err("samples: {t}", .{err}); }
/// Sends nowhere: there is no account to send from. fn send(context: *anyopaque, _: Compose.Outgoing) void { const self: *Samples = @ptrCast(@alignCast(context)); self.desk.sent(true) catch |err| log.err("samples: {t}", .{err}); }
/// Keeps the draft in memory only, as compose has it. fn save(_: *anyopaque, _: Compose.Outgoing) void {}
fn discard(_: *anyopaque) void {}};
/// Where opened attachments are saved: $XDG_DOWNLOAD_DIR, else/// ~/Downloads; empty when there is no home.fn downloads(arena: mem.Allocator, environ: *const std.process.Environ.Map) []const u8 { if (environ.get("XDG_DOWNLOAD_DIR")) |dir| return dir; const home = environ.get("HOME") orelse return ""; return mem.concat(arena, u8, &.{ home, "/Downloads" }) catch "";}
/// Where senders' photos are kept: $XDG_CACHE_HOME/parcel/avatars, else/// ~/.cache/parcel/avatars; empty when there is no home.fn avatars(arena: mem.Allocator, environ: *const std.process.Environ.Map) []const u8 { if (environ.get("XDG_CACHE_HOME")) |dir| return mem.concat(arena, u8, &.{ dir, "/parcel/avatars" }) catch ""; const home = environ.get("HOME") orelse return ""; return mem.concat(arena, u8, &.{ home, "/.cache/parcel/avatars" }) catch "";}
/// Signs in to `args`' account: `gmail NAME`, `fastmail NAME`, `jmap/// NAME URL`, or Gmail as the first account when none is named.fn login(init: std.process.Init, settings: ?Settings, args: []const [:0]const u8) !void { const kind: []const u8 = if (args.len > 0) args[0] else "gmail"; const jmap = mem.eql(u8, kind, "jmap"); if (args.len > @as(usize, if (jmap) 3 else 2) or (jmap and args.len != 3)) usage(init.io); const default: []const u8 = if (mem.eql(u8, kind, "fastmail")) "Fastmail" else first_account; const name = if (args.len >= 2) args[1] else default; if (name.len == 0 or name[0] == '.' or mem.findScalar(u8, name, '/') != null) { say("An account's name is its directory's: no slash, and not starting with a dot.\n", init.io, .{}); std.process.exit(2); } if (mem.eql(u8, kind, "fastmail")) return loginJmap(init, settings, name, Jmap.fastmail); if (jmap) return loginJmap(init, settings, name, args[2]); if (!mem.eql(u8, kind, "gmail")) usage(init.io); const arena = init.arena.allocator(); const client = try oauth.Client.load(arena, init.io, init.environ_map) orelse { say( \\Parcel needs an OAuth client to sign in with. In the Google Cloud console: \\ 1. Enable the Gmail API for a project. \\ 2. Under Google Auth Platform, Clients, create a client of type Desktop app. \\ 3. Download its JSON and save it as ~/.config/parcel/{s}. \\Then run `parcel login` again. \\ , init.io, .{oauth.Client.file_name}); std.process.exit(1); }; const top = settings orelse return error.NoStateDirectory; const s = top.account(name) orelse return error.NoStateDirectory; defer s.close(); const token = oauth.login(arena, init.io, client, .google, openBrowser) catch |err| switch (err) { // Logged with Google's reason. error.SignInRefused, error.TokenRefused => std.process.exit(1), else => |e| return e, }; try s.saveSecret(token_file, token.refresh orelse return error.NoRefreshToken); // They may be another account's. s.remove(cache.file_name); s.remove(Contacts.file_name); s.remove(Drafts.file_name); say("Signed in as {s}. Run `parcel` to see your mail.\n", init.io, .{name});}
/// Signs in to a JMAP server with a token typed at the terminal: an API/// token, or for a server that takes a password, user:password. It is/// tried on the session resource at `url` before it is kept.fn loginJmap(init: std.process.Init, settings: ?Settings, name: []const u8, url: []const u8) !void { const arena = init.arena.allocator(); if (mem.eql(u8, url, Jmap.fastmail)) { say("Make an API token in Fastmail's Settings, Privacy & Security, Manage API tokens,\n" ++ "with access to Email and Email submission.\n", init.io, .{}); } say("Token: ", init.io, .{}); var buf: [1024]u8 = undefined; defer std.crypto.secureZero(u8, &buf); const token = mem.trim(u8, try readSecretLine(init.io, &buf), " \r\n"); say("\n", init.io, .{}); if (token.len == 0) std.process.exit(1); const headers = try arena.dupe([]const u8, &.{try Jmap.authorizationFor(arena, token)}); const response = try Http.fetch(arena, .{ .method = .get, .url = url, .headers = headers, .body = null }); if (response.status / 100 != 2) { say("{s} refused the token ({d}).\n", init.io, .{ url, response.status }); std.process.exit(1); } const top = settings orelse return error.NoStateDirectory; const s = top.account(name) orelse return error.NoStateDirectory; defer s.close(); try s.saveSecret(JmapSession.token_file, token); if (mem.eql(u8, url, Jmap.fastmail)) s.remove(JmapSession.url_file) else s.save(JmapSession.url_file, url); // They may be another account's. s.remove(cache.file_name); s.remove(Contacts.file_name); say("Signed in as {s}. Run `parcel` to see your mail.\n", init.io, .{name});}
/// A line from stdin, not echoed when it is a terminal.fn readSecretLine(io: Io, buf: []u8) ![]const u8 { const stdin = Io.File.stdin(); const fd = stdin.handle; const old = posix.tcgetattr(fd) catch null; if (old) |o| { var quiet = o; quiet.lflag.ECHO = false; posix.tcsetattr(fd, .NOW, quiet) catch |err| log.warn("the token will show as it is typed: {t}", .{err}); } defer if (old) |o| posix.tcsetattr(fd, .NOW, o) catch {}; var reader = stdin.readerStreaming(io, buf); return (try reader.interface.takeDelimiter('\n')) orelse "";}
/// Opens the sign-in page in the browser, and prints it in case there is/// none, as over SSH.fn openBrowser(io: Io, url: []const u8) void { say("Sign in at:\n\n {s}\n\n", io, .{url}); _ = std.process.spawn(io, .{ .argv = &.{ "xdg-open", url }, .stdin = .ignore, .stdout = .ignore, .stderr = .ignore, }) catch |err| log.info("xdg-open: {t}; open the link yourself", .{err});}
/// Writes to stderr, for the terminal running `parcel login`./// Nowhere is left to report a failure to write there.fn say(comptime format: []const u8, io: Io, args: anytype) void { var buf: [1024]u8 = undefined; const stderr = io.lockStderr(&buf, null) catch return; defer io.unlockStderr(); const w = &stderr.file_writer.interface; w.print(format, args) catch return; w.flush() catch return;}
test "the one account from before accounts becomes the first, with its sign-in and mail" { var tmp = testing.tmpDir(.{}); defer tmp.cleanup(); const top: Settings = .{ .io = testing.io, .dir = tmp.dir }; try top.saveSecret(token_file, "refresh"); top.save(Desk.filters_file, "INBOX"); top.save(LogFile.name, "kept"); var arena: std.heap.ArenaAllocator = .init(testing.allocator); defer arena.deinit();
migrate(top, arena.allocator()); const names = try top.accounts(arena.allocator()); try testing.expectEqual(1, names.len); try testing.expectEqualStrings(first_account, names[0]); const gmail = top.account(first_account).?; defer gmail.close(); var buf: [16]u8 = undefined; try testing.expectEqualStrings("refresh", gmail.load(token_file, &buf).?); try testing.expectEqualStrings("INBOX", gmail.load(Desk.filters_file, &buf).?); try testing.expect(top.load(token_file, &buf) == null); // The log is the app's, not the account's. try testing.expectEqualStrings("kept", top.load(LogFile.name, &buf).?);}
test { _ = Accounts; _ = @import("Backfill.zig"); _ = @import("Harvest.zig"); _ = @import("Corpus.zig"); _ = @import("Index.zig"); _ = @import("Segment.zig"); _ = Jmap; _ = JmapSession; _ = Desk; _ = Drafts; _ = @import("Gmail.zig"); _ = @import("Http.zig"); _ = LogFile; _ = Mailbox; _ = Notifier; _ = @import("Pager.zig"); _ = @import("Query.zig"); _ = Session; _ = Settings; _ = @import("Sync.zig"); _ = @import("Reader.zig"); _ = @import("Images.zig"); _ = @import("Avatars.zig"); _ = @import("portable_text.zig"); _ = @import("Zoom.zig"); _ = Compose; _ = Contacts; _ = @import("html.zig"); _ = @import("cards.zig"); _ = cache; _ = oauth; _ = sample; _ = @import("kit.zig"); _ = @import("mime.zig");}