@bobfrankston/mailx 1.0.310 → 1.0.317

package/packages/mailx-service/index.js

@@ -587,16 +587,33 @@ export class MailxService {
             throw new Error("Folder not found");
         const client = this.imapManager.createPublicClient(accountId);
         try {
-            if (client.deleteMailbox) {
-                await client.deleteMailbox(folder.path);
+            try {
+                if (client.deleteMailbox) {
+                    await client.deleteMailbox(folder.path);
+                }
+                else {
+                    await client.withConnection(async () => {
+                        await client.client.mailboxDelete(folder.path);
+                    });
+                }
             }
-            else {
-                await client.withConnection(async () => {
-                    await client.client.mailboxDelete(folder.path);
-                });
+            catch (e) {
+                // Server already doesn't have this folder — common case when
+                // the user deleted / renamed it from another client and mailx
+                // is still showing the stale local row. Silently treat as
+                // success and proceed with local cleanup; the user's intent
+                // ("make this go away") is met either way.
+                const msg = String(e?.message || e || "").toLowerCase();
+                const alreadyGone = /nonexistent|does not exist|no such|not found|NO \[.*\] Mailbox|404/i.test(msg);
+                if (!alreadyGone)
+                    throw e;
+                console.log(`  [folder] ${accountId} delete "${folder.path}": server says already gone — cleaning local DB`);
             }
             this.db.deleteFolder(folderId);
-            await client.logout();
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
         }
         finally {
             try {
@@ -647,6 +664,16 @@ export class MailxService {
     }
     // ── Drafts ──
     async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId) {
+        // Local-first: commit the draft to the local filesystem synchronously
+        // and return immediately. The IMAP APPEND (and the previous-draft
+        // delete) run in the background. Previously this method awaited IMAP
+        // inline, which produced the 30/120s `mailxapi timeout: saveDraft`
+        // the user reported — every IMAP stall (slow server, hung OAuth,
+        // maxed connection pool) froze autosave. The local `.eml` written
+        // below is the user's crash-safety net; IMAP is a sync target, not
+        // a prerequisite. X-Mailx-Draft-ID is carried in the MIME headers
+        // so the reconciler can de-duplicate on the server by header search
+        // even without the previousDraftUid round-trip.
         const settings = loadSettings();
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
@@ -663,7 +690,8 @@ export class MailxService {
             `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${bodyEncoded}`;
-        // Save local editing copy — crash recovery, keep last 3
+        // Local commit: write editing copy to disk. Crash recovery lives in
+        // the last 3 files. Synchronous fs (~ms) so the caller returns fast.
         try {
             const editingDir = path.join(getConfigDir(), "sending", accountId, "editing");
             fs.mkdirSync(editingDir, { recursive: true });
@@ -677,9 +705,16 @@ export class MailxService {
                 fs.unlinkSync(path.join(editingDir, files.shift()));
             }
         }
-        catch { /* ignore */ }
-        const draftUid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
-        return { draftUid, draftId: id };
+        catch { /* non-fatal — draft stays in memory at least */ }
+        // Background reconcile to server Drafts folder. Fire-and-forget —
+        // the ACK to the client is already on its way.
+        this.imapManager.saveDraft(accountId, raw, previousDraftUid, id).catch((e) => {
+            console.error(`  [draft] background IMAP save failed for ${id}: ${e?.message || e}`);
+            // Surface as an event so the UI can show a status-bar hint without
+            // blocking the caller. Draft is preserved on disk regardless.
+            this.emit?.("draftSaveDeferred", { accountId, draftId: id, error: String(e?.message || e) });
+        });
+        return { draftUid: null, draftId: id };
     }
     async deleteDraft(accountId, draftUid, draftId) {
         await this.imapManager.deleteDraft(accountId, draftUid, draftId);
@@ -1005,6 +1040,106 @@ export class MailxService {
         }
         return { suggestion: "" };
     }
+    /** Generic AI text transform — translate / proofread / summarize.
+     *  Shares the autocomplete provider config (provider, key, model). Each
+     *  feature has its own opt-in toggle (translateEnabled / proofreadEnabled),
+     *  default false. Returns empty text + reason when disabled or on error. */
+    async aiTransform(req) {
+        const cfg = loadAutocomplete();
+        if (cfg.provider === "off")
+            return { text: "", reason: "AI provider not configured" };
+        const featureGate = {
+            translate: cfg.translateEnabled,
+            proofread: cfg.proofreadEnabled,
+            summarize: cfg.proofreadEnabled, // bundled with proofread for now
+        };
+        if (!featureGate[req.action])
+            return { text: "", reason: `AI ${req.action} disabled in settings` };
+        const text = (req.text || "").slice(0, 8000); // sanity cap
+        if (!text.trim())
+            return { text: "", reason: "no input" };
+        const target = req.targetLang || "en";
+        let systemPrompt;
+        let userPrompt;
+        switch (req.action) {
+            case "translate":
+                systemPrompt = `You are a translator. Render the user's text into ${target}. Preserve formatting (paragraphs, lists). Output ONLY the translation, no explanation.`;
+                userPrompt = text;
+                break;
+            case "proofread":
+                systemPrompt = `You are an editor. Return the user's text with grammar, spelling, and clarity fixed. Preserve voice and meaning. Output ONLY the corrected text, no explanation.`;
+                userPrompt = text;
+                break;
+            case "summarize":
+                systemPrompt = `You are a summarizer. Render the user's text as a short paragraph (2-4 sentences). Output ONLY the summary.`;
+                userPrompt = text;
+                break;
+        }
+        try {
+            if (cfg.provider === "ollama") {
+                const res = await fetch(`${cfg.ollamaUrl}/api/generate`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        model: cfg.ollamaModel,
+                        prompt: `${systemPrompt}\n\n${userPrompt}`,
+                        stream: false,
+                        options: { num_predict: 1024 },
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `ollama ${res.status}` };
+                const data = await res.json();
+                return { text: (data.response || "").trim() };
+            }
+            if (cfg.provider === "claude") {
+                const res = await fetch("https://api.anthropic.com/v1/messages", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": cfg.cloudApiKey,
+                        "anthropic-version": "2023-06-01",
+                    },
+                    body: JSON.stringify({
+                        model: cfg.cloudModel,
+                        max_tokens: 2048,
+                        system: systemPrompt,
+                        messages: [{ role: "user", content: userPrompt }],
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `claude ${res.status}` };
+                const data = await res.json();
+                return { text: (data.content?.[0]?.text || "").trim() };
+            }
+            if (cfg.provider === "openai") {
+                const res = await fetch("https://api.openai.com/v1/chat/completions", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${cfg.cloudApiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: cfg.cloudModel,
+                        max_tokens: 2048,
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: userPrompt },
+                        ],
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `openai ${res.status}` };
+                const data = await res.json();
+                return { text: (data.choices?.[0]?.message?.content || "").trim() };
+            }
+        }
+        catch (e) {
+            console.error(`  [aiTransform] ${cfg.provider} ${req.action} error: ${e.message}`);
+            return { text: "", reason: e.message };
+        }
+        return { text: "", reason: "no provider matched" };
+    }
 }
 /** Trim suggestion: remove leading/trailing whitespace, cap at sentence boundary */
 function trimSuggestion(text) {

package/packages/mailx-service/jsonrpc.js

@@ -137,6 +137,10 @@ async function dispatchAction(svc, action, p) {
         case "saveAutocompleteSettings":
             svc.saveAutocompleteSettings(p);
             return { ok: true };
+        // AI transform (translate / proofread / summarize) — gated by per-feature
+        // toggles in autocomplete settings, both default false.
+        case "aiTransform":
+            return svc.aiTransform(p);
         // Attachments
         case "getAttachment": {
             const att = await svc.getAttachment(p.accountId, p.uid, p.attachmentId, p.folderId);

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

@@ -225,6 +225,12 @@ export interface AutocompleteSettings {
     cloudModel: string;
     debounceMs: number;
     maxTokens: number;
+    /** Per-feature opt-in for non-autocomplete AI helpers. All default false
+     *  per user preference (2026-04-21): AI features should be controlled by
+     *  a flag, initially OFF in settings. Provider config is shared with
+     *  autocomplete (provider, cloudApiKey, cloudModel, etc.). */
+    translateEnabled?: boolean;
+    proofreadEnabled?: boolean;
 }
 export interface AutocompleteRequest {
     subject: string;
@@ -235,6 +241,21 @@ export interface AutocompleteRequest {
 export interface AutocompleteResponse {
     suggestion: string;
 }
+export interface AiTransformRequest {
+    /** translate = render in `targetLang`; proofread = corrected version
+     *  with grammar/spelling fixes; summarize = short paragraph summary. */
+    action: "translate" | "proofread" | "summarize";
+    text: string;
+    /** ISO-639-1 (or BCP-47) language code for translate. Defaults to "en". */
+    targetLang?: string;
+}
+export interface AiTransformResponse {
+    /** Transformed text. Empty when AI is disabled / provider error / feature
+     *  not enabled — caller should treat empty as "no result". */
+    text: string;
+    /** Optional reason for empty result, surfaced to UI status bar. */
+    reason?: string;
+}
 /** Body storage backend interface -- implementations are swappable */
 export interface MessageStore {
     putMessage(accountId: string, folderId: number, uid: number, raw: Buffer): Promise<string>;