@bobfrankston/mailx 1.0.174 → 1.0.176

package/client/.msger-window.json

@@ -0,0 +1 @@
+{"height":1047,"width":1844,"x":531,"y":264}

package/client/compose/editor.js

@@ -8,9 +8,12 @@ function createQuillEditor(container) {
         placeholder: "Write your message...",
         modules: {
             toolbar: [
+                [{ font: [] }, { size: ["small", false, "large", "huge"] }],
                 [{ header: [1, 2, 3, false] }],
                 ["bold", "italic", "underline", "strike"],
+                [{ color: [] }, { background: [] }],
                 [{ list: "ordered" }, { list: "bullet" }],
+                [{ align: [] }],
                 ["blockquote", "link", "image"],
                 ["clean"]
             ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.174",
+  "version": "1.0.176",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.1",
     "@bobfrankston/miscinfo": "^1.0.7",
     "@bobfrankston/oauthsupport": "^1.0.20",
-    "@bobfrankston/msger": "^0.1.223",
+    "@bobfrankston/msger": "^0.1.225",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.d.ts

@@ -184,6 +184,8 @@ export declare class ImapManager extends EventEmitter {
     queueOutgoing(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Process local file queue — move to IMAP Outbox when server is reachable */
     private processLocalQueue;
+    /** Send a raw RFC 2822 message via SMTP for a given account */
+    private sendRawViaSMTP;
     /** Process Outbox — send pending messages with flag-based interlock */
     processOutbox(accountId: string): Promise<void>;
     /** Start background Outbox worker — runs immediately then every 10 seconds */

package/packages/mailx-imap/index.js

@@ -1624,7 +1624,7 @@ export class ImapManager extends EventEmitter {
     /** Save a debug copy of outgoing mail to the sending directory */
     saveSendingCopy(accountId, rawMessage, label) {
         try {
-            const sendingDir = path.join(import.meta.dirname, "..", "..", "sending", accountId);
+            const sendingDir = path.join(getConfigDir(), "sending", accountId);
             fs.mkdirSync(sendingDir, { recursive: true });
             const now = new Date();
             const pad2 = (n) => String(n).padStart(2, "0");
@@ -1665,7 +1665,7 @@ export class ImapManager extends EventEmitter {
             console.error(`  [outbox] IMAP queue failed: ${e.message} — saving locally`);
         }
         // Fallback: save to local file queue
-        const localQueue = path.join(import.meta.dirname, "..", "..", "outbox", accountId);
+        const localQueue = path.join(getConfigDir(), "outbox", accountId);
         fs.mkdirSync(localQueue, { recursive: true });
         const now = new Date();
         const pad2 = (n) => String(n).padStart(2, "0");
@@ -1675,12 +1675,29 @@ export class ImapManager extends EventEmitter {
     }
     /** Process local file queue — move to IMAP Outbox when server is reachable */
     async processLocalQueue(accountId) {
-        const localQueue = path.join(import.meta.dirname, "..", "..", "outbox", accountId);
+        const localQueue = path.join(getConfigDir(), "outbox", accountId);
         if (!fs.existsSync(localQueue))
             return;
         const files = fs.readdirSync(localQueue).filter(f => f.endsWith(".ltr"));
         if (files.length === 0)
             return;
+        // Gmail/API accounts: send directly via SMTP from local queue (no IMAP outbox)
+        if (this.isGmailAccount(accountId)) {
+            for (const file of files) {
+                const filePath = path.join(localQueue, file);
+                const raw = fs.readFileSync(filePath, "utf-8");
+                try {
+                    await this.sendRawViaSMTP(accountId, raw);
+                    fs.unlinkSync(filePath);
+                    console.log(`  [outbox] Sent local ${file} via SMTP`);
+                }
+                catch (e) {
+                    console.error(`  [outbox] Send failed for ${file}: ${e.message}`);
+                }
+            }
+            return;
+        }
+        // IMAP accounts: append to IMAP Outbox for multi-machine interlock
         try {
             const outboxPath = await this.ensureOutbox(accountId);
             const client = await this.createClientWithLimit(accountId);
@@ -1704,6 +1721,48 @@ export class ImapManager extends EventEmitter {
             // IMAP still unreachable — leave files for next attempt
         }
     }
+    /** Send a raw RFC 2822 message via SMTP for a given account */
+    async sendRawViaSMTP(accountId, raw) {
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account?.smtp)
+            throw new Error(`No SMTP config for ${accountId}`);
+        let smtpAuth;
+        if (account.smtp.auth === "password") {
+            smtpAuth = { user: account.smtp.user, pass: account.smtp.password };
+        }
+        else if (account.smtp.auth === "oauth2") {
+            const accessToken = await this.getOAuthToken(accountId);
+            if (!accessToken)
+                throw new Error("OAuth token not available");
+            smtpAuth = { type: "OAuth2", user: account.smtp.user, accessToken };
+        }
+        const { createTransport } = await import("nodemailer");
+        const transport = createTransport({
+            host: account.smtp.host,
+            port: account.smtp.port,
+            secure: account.smtp.port === 465,
+            auth: smtpAuth,
+            tls: { rejectUnauthorized: false },
+        });
+        const parseAddrs = (s) => s.match(/[\w.+-]+@[\w.-]+/g) || [];
+        const toMatch = raw.match(/^To:\s*(.+)$/mi);
+        const ccMatch = raw.match(/^Cc:\s*(.+)$/mi);
+        const bccMatch = raw.match(/^Bcc:\s*(.+)$/mi);
+        const fromMatch = raw.match(/^From:\s*(.+)$/mi);
+        const recipients = [
+            ...(toMatch ? parseAddrs(toMatch[1]) : []),
+            ...(ccMatch ? parseAddrs(ccMatch[1]) : []),
+            ...(bccMatch ? parseAddrs(bccMatch[1]) : []),
+        ];
+        const sender = fromMatch ? (parseAddrs(fromMatch[1])[0] || account.email) : account.email;
+        if (recipients.length === 0)
+            throw new Error("No recipients");
+        const rawToSend = raw.replace(/^Bcc:.*\r?\n/mi, "");
+        this.saveSendingCopy(accountId, rawToSend, "sent");
+        await transport.sendMail({ envelope: { from: sender, to: recipients }, raw: rawToSend });
+        console.log(`  [smtp] ${accountId}: sent to ${recipients.join(", ")}`);
+    }
     /** Process Outbox — send pending messages with flag-based interlock */
     async processOutbox(accountId) {
         const outboxFolder = this.findFolder(accountId, "outbox");
@@ -1712,7 +1771,7 @@ export class ImapManager extends EventEmitter {
         // Skip if this account's sync is failing — don't pile up connections
         if (this.connectionBackoff.has(accountId) && Date.now() < (this.connectionBackoff.get(accountId) || 0))
             return;
-        // Gmail uses SMTP for sending (not IMAP outbox) — skip IMAP outbox check
+        // Gmail: skip IMAP outbox check — sending handled by processLocalQueue which sends directly via SMTP
         if (this.isGmailAccount(accountId))
             return;
         const settings = loadSettings();

package/packages/mailx-service/index.js

@@ -6,6 +6,42 @@
 import * as dns from "node:dns/promises";
 import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorePath, getStorageInfo } from "@bobfrankston/mailx-settings";
 import { simpleParser } from "mailparser";
+// ── Quoted-printable encoding (readable in debug .eml files) ──
+function encodeQuotedPrintable(text) {
+    const bytes = Buffer.from(text, "utf-8");
+    let line = "";
+    let result = "";
+    for (let i = 0; i < bytes.length; i++) {
+        const b = bytes[i];
+        let encoded;
+        if (b === 0x0D && bytes[i + 1] === 0x0A) {
+            // CRLF — output as-is
+            result += line + "\r\n";
+            line = "";
+            i++; // skip LF
+            continue;
+        }
+        else if (b === 0x0A) {
+            // Bare LF — normalize to CRLF
+            result += line + "\r\n";
+            line = "";
+            continue;
+        }
+        else if ((b >= 33 && b <= 126 && b !== 61) || b === 9 || b === 32) {
+            encoded = String.fromCharCode(b);
+        }
+        else {
+            encoded = "=" + b.toString(16).toUpperCase().padStart(2, "0");
+        }
+        if (line.length + encoded.length > 75) {
+            result += line + "=\r\n";
+            line = "";
+        }
+        line += encoded;
+    }
+    result += line;
+    return result;
+}
 // ── Email provider detection (MX-based) ──
 const GOOGLE_DOMAINS = ["gmail.com", "googlemail.com"];
 const MS_DOMAINS = ["outlook.com", "hotmail.com", "live.com"];
@@ -308,7 +344,7 @@ export class MailxService {
         const cc = msg.cc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
         const bcc = msg.bcc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
         const body = msg.bodyHtml || msg.bodyText || "";
-        const bodyBase64 = Buffer.from(body, "utf-8").toString("base64").replace(/(.{76})/g, "$1\r\n");
+        const bodyEncoded = encodeQuotedPrintable(body);
         // Generate a unique Message-ID (required for threading, dedup, and RFC compliance)
         const domain = account.email.split("@")[1] || "mailx.local";
         const messageId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@${domain}>`;
@@ -319,9 +355,9 @@ export class MailxService {
             `Message-ID: ${messageId}`,
             msg.inReplyTo ? `In-Reply-To: ${msg.inReplyTo}` : null,
             msg.references?.length ? `References: ${msg.references.join(" ")}` : null,
-            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: base64`,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
         ].filter(h => h !== null).join("\r\n");
-        const rawMessage = `${headers}\r\n\r\n${bodyBase64}`;
+        const rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
         this.imapManager.queueOutgoingLocal(account.id, rawMessage);
         console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
         for (const addr of msg.to)
@@ -491,15 +527,15 @@ export class MailxService {
         // Generate or reuse a stable draft ID for dedup
         const id = draftId || `mailx-draft-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const body = bodyHtml || bodyText || "";
-        const bodyBase64 = Buffer.from(body, "utf-8").toString("base64").replace(/(.{76})/g, "$1\r\n");
+        const bodyEncoded = encodeQuotedPrintable(body);
         const headers = [
             `From: ${account.name} <${account.email}>`,
             to ? `To: ${to}` : null, cc ? `Cc: ${cc}` : null,
             `Subject: ${subject || "(no subject)"}`, `Date: ${new Date().toUTCString()}`,
             `X-Mailx-Draft-ID: ${id}`,
-            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: base64`,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
         ].filter(h => h !== null).join("\r\n");
-        const raw = `${headers}\r\n\r\n${bodyBase64}`;
+        const raw = `${headers}\r\n\r\n${bodyEncoded}`;
         const uid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
         return { uid, draftId: id };
     }