@bobfrankston/mailx 1.0.12 → 1.0.13

package/packages/mailx-core/index.js

@@ -0,0 +1,323 @@
+/**
+ * @bobfrankston/mailx-core
+ * Core mail functions — callable directly via IPC or wrapped by Express.
+ * No HTTP, no Express, no WebSocket. Just plain async functions.
+ */
+import { MailxDB } from "@bobfrankston/mailx-store";
+import { ImapManager } from "@bobfrankston/mailx-imap";
+import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, getConfigDir, getStorePath, initLocalConfig } from "@bobfrankston/mailx-settings";
+import { simpleParser } from "mailparser";
+// ── Initialization ──
+let db;
+let imapManager;
+const eventHandlers = [];
+export function onEvent(handler) {
+    eventHandlers.push(handler);
+}
+function emit(event) {
+    for (const h of eventHandlers) {
+        try {
+            h(event);
+        }
+        catch { /* ignore handler errors */ }
+    }
+}
+export async function initialize() {
+    initLocalConfig();
+    const dbDir = getConfigDir();
+    db = new MailxDB(dbDir);
+    imapManager = new ImapManager(db);
+    // Seed contacts
+    const seeded = db.seedContactsFromMessages();
+    if (seeded > 0)
+        console.log(`  Seeded ${seeded} contacts`);
+    // Search index — only if empty
+    let ftsCount = 0;
+    try {
+        ftsCount = db.db.prepare("SELECT COUNT(*) as cnt FROM messages_fts").get()?.cnt || 0;
+    }
+    catch { /* */ }
+    if (ftsCount === 0) {
+        const indexed = db.rebuildSearchIndex();
+        if (indexed > 0)
+            console.log(`  Search index: ${indexed} messages`);
+    }
+    // Add accounts
+    const settings = loadSettings();
+    for (const account of settings.accounts) {
+        if (!account.enabled)
+            continue;
+        try {
+            await imapManager.addAccount(account);
+            console.log(`  Account added: ${account.name} (${account.id})`);
+        }
+        catch (e) {
+            console.error(`  Failed to add account ${account.id}: ${e.message}`);
+        }
+    }
+    // Wire events to push notifications
+    imapManager.on("syncProgress", (accountId, phase, progress) => {
+        emit({ type: "syncProgress", accountId, phase, progress });
+    });
+    imapManager.on("folderCountsChanged", (accountId, counts) => {
+        emit({ type: "folderCountsChanged", accountId, counts });
+    });
+    // Initial sync + IDLE
+    if (settings.accounts.some(a => a.enabled)) {
+        console.log("  Starting initial sync...");
+        imapManager.syncAll().then(async () => {
+            console.log("  Initial sync complete");
+            await imapManager.startWatching();
+            imapManager.syncAllContacts().catch(e => console.error(`  Google Contacts sync error: ${e.message}`));
+        }).catch(e => {
+            console.error(`  Initial sync error: ${e.message}`);
+        });
+    }
+    imapManager.startPeriodicSync(settings.sync.intervalMinutes);
+    imapManager.startOutboxWorker();
+}
+export async function shutdown() {
+    imapManager?.stopPeriodicSync();
+    imapManager?.stopOutboxWorker();
+    await imapManager?.shutdown();
+    db?.close();
+}
+// ── HTML Sanitization ──
+function sanitizeHtml(html) {
+    let hasRemoteContent = false;
+    let clean = html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    clean = clean.replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+    clean = clean.replace(/<img\b([^>]*)\bsrc\s*=\s*("[^"]*"|'[^']*')/gi, (match, before, src) => {
+        const url = src.slice(1, -1);
+        if (url.startsWith("data:") || url.startsWith("cid:"))
+            return match;
+        hasRemoteContent = true;
+        return `<img${before}src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Crect fill='%23888' width='20' height='20' rx='3'/%3E%3Ctext x='10' y='14' text-anchor='middle' fill='white' font-size='12'%3E⊘%3C/text%3E%3C/svg%3E" data-blocked-src=${src} title="Remote image blocked"`;
+    });
+    clean = clean.replace(/<link\b[^>]*rel\s*=\s*["']stylesheet["'][^>]*>/gi, (match) => {
+        hasRemoteContent = true;
+        return `<!-- blocked: ${match.replace(/--/g, "")} -->`;
+    });
+    clean = clean.replace(/url\s*\(\s*(['"]?)(https?:\/\/[^)]+)\1\s*\)/gi, (_match, _q, url) => {
+        hasRemoteContent = true;
+        return `url("") /* blocked: ${url} */`;
+    });
+    clean = clean.replace(/<\/?form\b[^>]*>/gi, "");
+    clean = clean.replace(/<iframe\b[^>]*>[\s\S]*?<\/iframe>/gi, "");
+    return { html: clean, hasRemoteContent };
+}
+// ── API Functions ──
+export function getAccounts() {
+    return db.getAccounts();
+}
+export function getFolders(params) {
+    return db.getFolders(params.accountId);
+}
+export function getMessages(params) {
+    return db.getMessages({
+        accountId: params.accountId,
+        folderId: params.folderId,
+        page: params.page || 1,
+        pageSize: params.pageSize || 50,
+        sort: params.sort || "date",
+        sortDir: params.sortDir || "desc",
+        search: params.search,
+    });
+}
+export function getUnifiedInbox(params) {
+    return db.getUnifiedInbox(params.page, params.pageSize);
+}
+export async function getMessage(params) {
+    const { accountId, uid } = params;
+    let allowRemote = params.allowRemote || false;
+    const envelope = db.getMessageByUid(accountId, uid, params.folderId);
+    if (!envelope)
+        throw new Error("Message not found");
+    let bodyHtml = "";
+    let bodyText = "";
+    let hasRemoteContent = false;
+    let attachments = [];
+    let deliveredTo = "";
+    let returnPath = "";
+    let listUnsubscribe = "";
+    const raw = await imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+    if (raw) {
+        const parsed = await simpleParser(raw);
+        bodyHtml = parsed.html || "";
+        bodyText = parsed.text || "";
+        attachments = (parsed.attachments || []).map((a, i) => ({
+            id: i,
+            filename: a.filename || `attachment-${i}`,
+            mimeType: a.contentType || "application/octet-stream",
+            size: a.size || 0,
+            contentId: a.contentId || "",
+        }));
+        // Extract useful headers for the UI
+        const hdr = (key) => {
+            const v = parsed.headers.get(key);
+            if (!v)
+                return "";
+            if (typeof v === "string")
+                return v;
+            if (typeof v === "object" && "text" in v)
+                return v.text || "";
+            if (typeof v === "object" && "value" in v)
+                return String(v.value);
+            return String(v);
+        };
+        deliveredTo = hdr("delivered-to");
+        returnPath = hdr("return-path").replace(/[<>]/g, "");
+        listUnsubscribe = hdr("list-unsubscribe");
+    }
+    if (bodyHtml && !allowRemote) {
+        const allowList = loadAllowlist();
+        const senderAddr = envelope.from?.address || "";
+        const senderDomain = senderAddr.split("@")[1] || "";
+        const toAddrs = (envelope.to || []).map((a) => a.address);
+        const isAllowed = allowList.senders.includes(senderAddr) ||
+            allowList.domains.includes(senderDomain) ||
+            toAddrs.some((a) => allowList.recipients?.includes(a));
+        if (isAllowed) {
+            allowRemote = true;
+        }
+        else {
+            const result = sanitizeHtml(bodyHtml);
+            bodyHtml = result.html;
+            hasRemoteContent = result.hasRemoteContent;
+        }
+    }
+    // Build .eml file path for "View Source"
+    const storePath = getStorePath();
+    const emlPath = `${storePath}/${accountId}/${envelope.folderId}/${envelope.uid}.eml`;
+    return { ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote, attachments, deliveredTo, returnPath, listUnsubscribe, emlPath };
+}
+export async function updateFlags(params) {
+    const envelope = db.getMessageByUid(params.accountId, params.uid);
+    await imapManager.updateFlagsLocal(params.accountId, params.uid, envelope?.folderId || 0, params.flags);
+}
+export async function deleteMessage(params) {
+    const envelope = db.getMessageByUid(params.accountId, params.uid);
+    if (!envelope)
+        throw new Error("Message not found");
+    await imapManager.trashMessage(params.accountId, envelope.folderId, envelope.uid);
+}
+export async function undeleteMessage(params) {
+    await imapManager.undeleteMessage(params.accountId, params.uid, params.folderId);
+}
+export async function sendMessage(params) {
+    const settings = loadSettings();
+    const account = settings.accounts.find(a => a.id === params.from);
+    if (!account)
+        throw new Error(`Unknown account: ${params.from}`);
+    const to = params.to.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const cc = params.cc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const bcc = params.bcc?.map(a => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+    const headers = [
+        `From: ${account.name} <${account.email}>`,
+        `To: ${to}`,
+        cc ? `Cc: ${cc}` : null,
+        bcc ? `Bcc: ${bcc}` : null,
+        `Subject: ${params.subject}`,
+        `Date: ${new Date().toUTCString()}`,
+        params.inReplyTo ? `In-Reply-To: ${params.inReplyTo}` : null,
+        params.references?.length ? `References: ${params.references.join(" ")}` : null,
+        `MIME-Version: 1.0`,
+        `Content-Type: text/html; charset=UTF-8`,
+    ].filter(h => h !== null).join("\r\n");
+    const rawMessage = `${headers}\r\n\r\n${params.bodyHtml || params.bodyText || ""}`;
+    imapManager.queueOutgoingLocal(account.id, rawMessage);
+    for (const addr of params.to)
+        db.recordSentAddress(addr.name, addr.address);
+    if (params.cc)
+        for (const addr of params.cc)
+            db.recordSentAddress(addr.name, addr.address);
+    if (params.bcc)
+        for (const addr of params.bcc)
+            db.recordSentAddress(addr.name, addr.address);
+}
+export async function saveDraft(params) {
+    const settings = loadSettings();
+    const account = settings.accounts.find(a => a.id === params.accountId);
+    if (!account)
+        throw new Error(`Unknown account: ${params.accountId}`);
+    const headers = [
+        `From: ${account.name} <${account.email}>`,
+        params.to ? `To: ${params.to}` : null,
+        params.cc ? `Cc: ${params.cc}` : null,
+        `Subject: ${params.subject || "(no subject)"}`,
+        `Date: ${new Date().toUTCString()}`,
+        `MIME-Version: 1.0`,
+        `Content-Type: text/html; charset=UTF-8`,
+    ].filter(h => h !== null).join("\r\n");
+    const raw = `${headers}\r\n\r\n${params.bodyHtml || params.bodyText || ""}`;
+    return await imapManager.saveDraft(params.accountId, raw, params.previousDraftUid);
+}
+export async function deleteDraft(params) {
+    await imapManager.deleteDraft(params.accountId, params.draftUid);
+}
+export function searchMessages(params) {
+    if (!params.query.trim())
+        return { items: [], total: 0, page: 1, pageSize: 50 };
+    return db.searchMessages(params.query, params.page || 1, params.pageSize || 50);
+}
+export function searchContacts(params) {
+    if (params.query.length < 1)
+        return [];
+    return db.searchContacts(params.query);
+}
+export async function syncAll() {
+    await imapManager.syncAll();
+}
+export function getSyncPending() {
+    return { pending: db.getTotalPendingSyncCount() };
+}
+export function allowRemoteContent(params) {
+    const list = loadAllowlist();
+    if (params.type === "sender" && !list.senders.includes(params.value))
+        list.senders.push(params.value);
+    else if (params.type === "domain" && !list.domains.includes(params.value))
+        list.domains.push(params.value);
+    else if (params.type === "recipient") {
+        if (!list.recipients)
+            list.recipients = [];
+        if (!list.recipients.includes(params.value))
+            list.recipients.push(params.value);
+    }
+    saveAllowlist(list);
+}
+export function getSettings() {
+    return loadSettings();
+}
+export function saveSettingsData(data) {
+    saveSettings(data);
+}
+export function rebuildSearchIndex() {
+    return db.rebuildSearchIndex();
+}
+export function seedContacts() {
+    return db.seedContactsFromMessages();
+}
+export async function syncGoogleContacts() {
+    await imapManager.syncAllContacts();
+}
+export function getVersion() {
+    return { server: "1.0.0", client: "1.0.0" }; // Updated by build
+}
+// ── Action dispatcher for IPC ──
+const actions = {
+    getAccounts, getFolders, getMessages, getUnifiedInbox, getMessage,
+    updateFlags, deleteMessage, undeleteMessage, sendMessage,
+    saveDraft, deleteDraft, searchMessages, searchContacts,
+    syncAll, getSyncPending, allowRemoteContent,
+    getSettings, saveSettingsData, rebuildSearchIndex,
+    seedContacts, syncGoogleContacts, getVersion,
+};
+/** Dispatch an action by name — used by IPC and Express wrapper */
+export async function dispatch(action, params = {}) {
+    const fn = actions[action];
+    if (!fn)
+        throw new Error(`Unknown action: ${action}`);
+    return await fn(params);
+}
+export { db, imapManager };
+//# sourceMappingURL=index.js.map

package/packages/mailx-core/ipc.d.ts

@@ -0,0 +1,13 @@
+/**
+ * IPC protocol — stdin/stdout JSON lines for Rust↔Node communication.
+ * Rust launcher sends JSON requests, Node dispatches to core functions,
+ * sends JSON responses back. Events pushed to stdout as well.
+ *
+ * Protocol:
+ *   Request:  { "_action": "getMessages", "_cbid": "5", "accountId": "bobma", ... }
+ *   Response: { "_type": "response", "_cbid": "5", "result": { ... } }
+ *   Error:    { "_type": "error", "_cbid": "5", "error": "message" }
+ *   Event:    { "_type": "event", "data": { "type": "folderCountsChanged", ... } }
+ */
+export declare function startIPC(): Promise<void>;
+//# sourceMappingURL=ipc.d.ts.map

package/packages/mailx-core/ipc.js

@@ -0,0 +1,56 @@
+/**
+ * IPC protocol — stdin/stdout JSON lines for Rust↔Node communication.
+ * Rust launcher sends JSON requests, Node dispatches to core functions,
+ * sends JSON responses back. Events pushed to stdout as well.
+ *
+ * Protocol:
+ *   Request:  { "_action": "getMessages", "_cbid": "5", "accountId": "bobma", ... }
+ *   Response: { "_type": "response", "_cbid": "5", "result": { ... } }
+ *   Error:    { "_type": "error", "_cbid": "5", "error": "message" }
+ *   Event:    { "_type": "event", "data": { "type": "folderCountsChanged", ... } }
+ */
+import * as readline from "node:readline";
+import { dispatch, initialize, onEvent } from "./index.js";
+export async function startIPC() {
+    // Initialize core
+    await initialize();
+    // Push events to stdout
+    onEvent((event) => {
+        const line = JSON.stringify({ _type: "event", data: event });
+        process.stdout.write(line + "\n");
+    });
+    // Read JSON lines from stdin
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    rl.on("line", async (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return; // Skip malformed JSON
+        }
+        const { _action, _cbid, ...params } = msg;
+        if (!_action || !_cbid)
+            return;
+        try {
+            const result = await dispatch(_action, params);
+            process.stdout.write(JSON.stringify({ _type: "response", _cbid, result }) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ _type: "error", _cbid, error: e.message }) + "\n");
+        }
+    });
+    rl.on("close", () => {
+        console.error("IPC stdin closed, shutting down");
+        process.exit(0);
+    });
+    console.error("IPC ready");
+}
+// If run directly, start IPC mode
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("ipc.js")) {
+    startIPC().catch(e => {
+        console.error(`IPC startup error: ${e.message}`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=ipc.js.map

package/packages/mailx-core/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@bobfrankston/mailx-core",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/mailx-types": "file:../mailx-types",
+    "@bobfrankston/mailx-store": "file:../mailx-store",
+    "@bobfrankston/mailx-imap": "file:../mailx-imap",
+    "@bobfrankston/mailx-settings": "file:../mailx-settings",
+    "mailparser": "^3.7.2"
+  }
+}

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

@@ -28,6 +28,8 @@ export declare class ImapManager extends EventEmitter {
     private syncing;
     private inboxSyncing;
     constructor(db: MailxDB);
+    /** Get OAuth access token for an account (for SMTP auth) */
+    getOAuthToken(accountId: string): Promise<string | null>;
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     private createClient;
     /** Register an account */
@@ -59,6 +61,8 @@ export declare class ImapManager extends EventEmitter {
     trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
     /** Move a message between folders — local-first, queues IMAP sync */
     moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
+    /** Move message across accounts using iflow's moveMessageToServer */
+    moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
     /** Undelete — move from Trash back to original folder */
     undeleteMessage(accountId: string, uid: number, originalFolderId: number): Promise<void>;
     /** Update flags — local-first, queues IMAP sync */
@@ -88,7 +92,7 @@ export declare class ImapManager extends EventEmitter {
     private processLocalQueue;
     /** Process Outbox — send pending messages with flag-based interlock */
     processOutbox(accountId: string): Promise<void>;
-    /** Start background Outbox worker — checks every 10 seconds */
+    /** Start background Outbox worker — runs immediately then every 10 seconds */
     startOutboxWorker(): void;
     /** Stop Outbox worker */
     stopOutboxWorker(): void;

package/packages/mailx-imap/index.js

@@ -55,6 +55,13 @@ export class ImapManager extends EventEmitter {
         const storePath = getStorePath();
         this.bodyStore = new FileMessageStore(storePath);
     }
+    /** Get OAuth access token for an account (for SMTP auth) */
+    async getOAuthToken(accountId) {
+        const config = this.configs.get(accountId);
+        if (!config || !config.tokenProvider)
+            return null;
+        return config.tokenProvider();
+    }
     /** Create a fresh ImapClient for an account (disposable, single-use) */
     createClient(accountId) {
         const config = this.configs.get(accountId);
@@ -106,12 +113,7 @@ export class ImapManager extends EventEmitter {
             this.db.upsertFolder(accountId, folder.path, folder.name || folder.path.split(folder.delimiter || "/").pop() || folder.path, specialUse, folder.delimiter || "/");
         }
         this.emit("syncProgress", accountId, "folders", 100);
-        const dbFolders = this.db.getFolders(accountId);
-        // Register folder names for human-readable store paths
-        for (const f of dbFolders) {
-            this.bodyStore.registerFolder(f.id, f.path);
-        }
-        return dbFolders;
+        return this.db.getFolders(accountId);
     }
     /** Sync messages for a specific folder */
     async syncFolder(accountId, folderId, client) {
@@ -271,8 +273,6 @@ export class ImapManager extends EventEmitter {
                 const folders = await this.syncFolders(accountId, client);
                 await client.logout();
                 client = null;
-                // Fresh client for message sync (getFolderList corrupts imapflow state)
-                client = this.createClient(accountId);
                 // INBOX first so it's available fastest
                 folders.sort((a, b) => {
                     if (a.specialUse === "inbox")
@@ -281,11 +281,22 @@ export class ImapManager extends EventEmitter {
                         return 1;
                     return 0;
                 });
+                // Fresh client per folder — IMAP connections drop mid-sync on large accounts
                 for (const folder of folders) {
                     try {
+                        client = this.createClient(accountId);
                         await this.syncFolder(accountId, folder.id, client);
+                        await client.logout();
+                        client = null;
                     }
                     catch (e) {
+                        if (client) {
+                            try {
+                                await client.logout();
+                            }
+                            catch { /* ignore */ }
+                            client = null;
+                        }
                         if (e.responseText?.includes("doesn't exist")) {
                             console.log(`  Removing non-existent folder: ${folder.path}`);
                             this.db.deleteFolder(folder.id);
@@ -295,8 +306,6 @@ export class ImapManager extends EventEmitter {
                         }
                     }
                 }
-                await client.logout();
-                client = null;
                 this.emit("syncComplete", accountId);
             }
             catch (e) {
@@ -493,6 +502,38 @@ export class ImapManager extends EventEmitter {
         // Try immediate sync
         this.processSyncActions(accountId).catch(() => { });
     }
+    /** Move message across accounts using iflow's moveMessageToServer */
+    async moveMessageCrossAccount(fromAccountId, uid, fromFolderId, toAccountId, toFolderId) {
+        const fromFolders = this.db.getFolders(fromAccountId);
+        const fromFolder = fromFolders.find(f => f.id === fromFolderId);
+        if (!fromFolder)
+            throw new Error(`Source folder ${fromFolderId} not found`);
+        const toFolders = this.db.getFolders(toAccountId);
+        const toFolder = toFolders.find(f => f.id === toFolderId);
+        if (!toFolder)
+            throw new Error(`Target folder ${toFolderId} not found`);
+        const sourceClient = this.createClient(fromAccountId);
+        const targetClient = this.createClient(toAccountId);
+        try {
+            const msg = await sourceClient.fetchMessageByUid(fromFolder.path, uid, { source: true });
+            if (!msg)
+                throw new Error(`Message UID ${uid} not found in ${fromFolder.path}`);
+            await sourceClient.moveMessageToServer(msg, fromFolder.path, targetClient, toFolder.path);
+            // Remove from local DB
+            this.db.deleteMessage(fromAccountId, uid);
+            console.log(`  Cross-account move: ${fromAccountId}/${fromFolder.path} UID ${uid} → ${toAccountId}/${toFolder.path}`);
+        }
+        finally {
+            try {
+                await sourceClient.logout();
+            }
+            catch { /* ignore */ }
+            try {
+                await targetClient.logout();
+            }
+            catch { /* ignore */ }
+        }
+    }
     /** Undelete — move from Trash back to original folder */
     async undeleteMessage(accountId, uid, originalFolderId) {
         const trash = this.findFolder(accountId, "trash");
@@ -817,13 +858,21 @@ export class ImapManager extends EventEmitter {
                 }
                 // Send via SMTP
                 try {
+                    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 — re-authenticate");
+                        smtpAuth = { type: "OAuth2", user: account.smtp.user, accessToken };
+                    }
                     const transport = createTransport({
                         host: account.smtp.host,
                         port: account.smtp.port,
                         secure: account.smtp.port === 465,
-                        auth: account.smtp.auth === "password"
-                            ? { user: account.smtp.user, pass: account.smtp.password }
-                            : undefined,
+                        auth: smtpAuth,
                         tls: { rejectUnauthorized: false },
                     });
                     // Parse recipients from raw message headers for SMTP envelope
@@ -874,10 +923,23 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Start background Outbox worker — checks every 10 seconds */
+    /** Start background Outbox worker — runs immediately then every 10 seconds */
     startOutboxWorker() {
         if (this.outboxInterval)
             return;
+        // Run once immediately on startup
+        const processAll = async () => {
+            for (const [accountId] of this.configs) {
+                try {
+                    await this.processLocalQueue(accountId);
+                    await this.processOutbox(accountId);
+                }
+                catch (e) {
+                    console.error(`  [outbox] Error for ${accountId}: ${e.message}`);
+                }
+            }
+        };
+        setTimeout(() => processAll(), 3000); // 3s after startup (let connections settle)
         this.outboxInterval = setInterval(async () => {
             for (const [accountId] of this.configs) {
                 try {