@bobfrankston/iflow-direct 0.1.13 → 0.1.15

package/bridge-transport.d.ts

@@ -1,30 +1,7 @@
 /**
- * Bridge transport for IMAP — uses msgapi.tcp from the native shell.
- * Works in any msgapi host: msga (MAUI), msger (Rust/wry), msgview (Electron).
- *
- * The native shell provides:
- *   msgapi.tcp.connect(host, port, tls) → streamId
- *   msgapi.tcp.write(streamId, data)
- *   msgapi.tcp.onData(streamId, callback)
- *   msgapi.tcp.upgradeTLS(streamId, servername)
- *   msgapi.tcp.close(streamId)
- *
- * TLS is handled natively — JS never sees raw TLS handshake.
+ * Back-compat re-export. `BridgeTransport` was renamed to `BridgeTcpTransport`
+ * and moved to @bobfrankston/tcp-transport. New code should import that
+ * directly. This shim keeps existing imports working.
  */
-import type { ImapTransport } from "./transport.js";
-export declare class BridgeTransport implements ImapTransport {
-    private streamId;
-    private dataHandler;
-    private closeHandler;
-    private errorHandler;
-    private _connected;
-    get connected(): boolean;
-    connect(host: string, port: number, tls: boolean, _servername?: string): Promise<void>;
-    upgradeTLS(servername?: string): Promise<void>;
-    write(data: string | Uint8Array): Promise<void>;
-    onData(handler: (data: string) => void): void;
-    onClose(handler: (hadError: boolean) => void): void;
-    onError(handler: (err: Error) => void): void;
-    close(): void;
-}
+export { BridgeTcpTransport as BridgeTransport } from "@bobfrankston/tcp-transport";
 //# sourceMappingURL=bridge-transport.d.ts.map

package/bridge-transport.js

@@ -1,60 +1,7 @@
 /**
- * Bridge transport for IMAP — uses msgapi.tcp from the native shell.
- * Works in any msgapi host: msga (MAUI), msger (Rust/wry), msgview (Electron).
- *
- * The native shell provides:
- *   msgapi.tcp.connect(host, port, tls) → streamId
- *   msgapi.tcp.write(streamId, data)
- *   msgapi.tcp.onData(streamId, callback)
- *   msgapi.tcp.upgradeTLS(streamId, servername)
- *   msgapi.tcp.close(streamId)
- *
- * TLS is handled natively — JS never sees raw TLS handshake.
+ * Back-compat re-export. `BridgeTransport` was renamed to `BridgeTcpTransport`
+ * and moved to @bobfrankston/tcp-transport. New code should import that
+ * directly. This shim keeps existing imports working.
  */
-export class BridgeTransport {
-    streamId = null;
-    dataHandler = null;
-    closeHandler = null;
-    errorHandler = null;
-    _connected = false;
-    get connected() { return this._connected; }
-    async connect(host, port, tls, _servername) {
-        this.streamId = await msgapi.tcp.connect(host, port, tls);
-        this._connected = true;
-        msgapi.tcp.onData(this.streamId, (data) => {
-            if (this.dataHandler)
-                this.dataHandler(data);
-        });
-        msgapi.tcp.onClose(this.streamId, (hadError) => {
-            this._connected = false;
-            if (this.closeHandler)
-                this.closeHandler(hadError);
-        });
-        msgapi.tcp.onError(this.streamId, (message) => {
-            if (this.errorHandler)
-                this.errorHandler(new Error(message));
-        });
-    }
-    async upgradeTLS(servername) {
-        if (this.streamId == null)
-            throw new Error("Not connected");
-        await msgapi.tcp.upgradeTLS(this.streamId, servername || "");
-    }
-    async write(data) {
-        if (this.streamId == null)
-            throw new Error("Not connected");
-        const str = typeof data === "string" ? data : new TextDecoder().decode(data);
-        await msgapi.tcp.write(this.streamId, str);
-    }
-    onData(handler) { this.dataHandler = handler; }
-    onClose(handler) { this.closeHandler = handler; }
-    onError(handler) { this.errorHandler = handler; }
-    close() {
-        this._connected = false;
-        if (this.streamId != null) {
-            msgapi.tcp.close(this.streamId);
-            this.streamId = null;
-        }
-    }
-}
+export { BridgeTcpTransport as BridgeTransport } from "@bobfrankston/tcp-transport";
 //# sourceMappingURL=bridge-transport.js.map

package/fetched-message.d.ts

@@ -0,0 +1,53 @@
+/**
+ * FetchedMessage — NativeFetchedMessage plus parsed-header state and convenience getters.
+ *
+ * Inherits the NativeFetchedMessage shape (via `implements`) so a FetchedMessage
+ * is-a NativeFetchedMessage: it can be passed anywhere the native interface is
+ * expected. Callers that want the raw shape treat it as NativeFetchedMessage;
+ * callers that want extras read `.ymd`, `.listUnsubscribe`, etc. directly.
+ */
+import type { NativeFetchedMessage } from "./imap-native.js";
+import type { AddressData } from "./imap-protocol.js";
+/** Case-insensitive multi-value header map (one key may repeat). */
+declare class HeaderMap {
+    private items;
+    add(key: string, value: string): void;
+    get(key: string): string[] | undefined;
+}
+export declare class FetchedMessage implements NativeFetchedMessage {
+    seq: number;
+    uid: number;
+    flags: Set<string>;
+    date: Date | null;
+    subject: string;
+    messageId: string;
+    from: AddressData[];
+    to: AddressData[];
+    cc: AddressData[];
+    bcc: AddressData[];
+    sender: AddressData[];
+    replyTo: AddressData[];
+    inReplyTo: string;
+    size: number;
+    source: string;
+    headers: string;
+    seen: boolean;
+    flagged: boolean;
+    answered: boolean;
+    draft: boolean;
+    parsedHeader: string[][];
+    headerSet: HeaderMap;
+    constructor(init: NativeFetchedMessage);
+    get unread(): boolean;
+    get deleted(): boolean;
+    get hasFlag(): boolean;
+    get ymd(): string | undefined;
+    /** Self-typed as a keyable record for dynamic address-field access by screening rules. */
+    get tcsb(): Record<string, AddressData[]>;
+    get listUnsubscribe(): string | undefined;
+    get xpriority(): string | undefined;
+    get importance(): string | undefined;
+    get deliveredTo(): string | undefined;
+}
+export {};
+//# sourceMappingURL=fetched-message.d.ts.map

package/fetched-message.js

@@ -0,0 +1,77 @@
+/**
+ * FetchedMessage — NativeFetchedMessage plus parsed-header state and convenience getters.
+ *
+ * Inherits the NativeFetchedMessage shape (via `implements`) so a FetchedMessage
+ * is-a NativeFetchedMessage: it can be passed anywhere the native interface is
+ * expected. Callers that want the raw shape treat it as NativeFetchedMessage;
+ * callers that want extras read `.ymd`, `.listUnsubscribe`, etc. directly.
+ */
+/** Case-insensitive multi-value header map (one key may repeat). */
+class HeaderMap {
+    items = {};
+    add(key, value) {
+        const k = key.toLowerCase();
+        (this.items[k] ||= []).push(value);
+    }
+    get(key) {
+        return this.items[key.toLowerCase()];
+    }
+}
+export class FetchedMessage {
+    // Native fields — populated by Object.assign in the constructor.
+    // `implements NativeFetchedMessage` forces this list to stay in sync.
+    seq;
+    uid;
+    flags;
+    date;
+    subject;
+    messageId;
+    from;
+    to;
+    cc;
+    bcc;
+    sender;
+    replyTo;
+    inReplyTo;
+    size;
+    source;
+    headers;
+    seen;
+    flagged;
+    answered;
+    draft;
+    // Parsed-header state
+    parsedHeader;
+    headerSet;
+    constructor(init) {
+        Object.assign(this, init);
+        // RFC 5322 unfold: a line starting with whitespace continues the prior one.
+        const unfolded = (init.headers || "").replace(/\r\n(\s)/g, "$1");
+        this.parsedHeader = unfolded
+            .split(/\r?\n/)
+            .filter(line => line.trim() !== "")
+            .map(line => {
+            const i = line.indexOf(":");
+            return i < 0 ? [line, ""] : [line.slice(0, i), line.slice(i + 1).trim()];
+        });
+        this.headerSet = new HeaderMap();
+        for (const [k, v] of this.parsedHeader)
+            this.headerSet.add(k, v);
+    }
+    // Flag convenience
+    get unread() { return !this.seen; }
+    get deleted() { return this.flags.has("\\Deleted"); }
+    get hasFlag() { return this.flags.size > 0; }
+    // Display
+    get ymd() { return this.date?.toLocaleDateString("se"); }
+    /** Self-typed as a keyable record for dynamic address-field access by screening rules. */
+    get tcsb() {
+        return this;
+    }
+    // Parsed-header lookups
+    get listUnsubscribe() { return this.headerSet.get("List-Unsubscribe")?.[0]; }
+    get xpriority() { return this.headerSet.get("X-Priority")?.[0]; }
+    get importance() { return this.headerSet.get("Importance")?.[0]; }
+    get deliveredTo() { return this.headerSet.get("Delivered-To")?.[0]; }
+}
+//# sourceMappingURL=fetched-message.js.map

package/folder-tree.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Folder tree builder — converts a flat NativeFolder[] into a nested tree.
+ * Equivalent to imapflow's listTree(), but pure JS and transport-agnostic.
+ * Parents are derived from path + delimiter (NativeFolder has no pre-parsed parent[]).
+ */
+import type { NativeFolder } from "./imap-native.js";
+export interface FolderTreeNode {
+    /** Root sentinel — only true on the returned top-level container */
+    root?: boolean;
+    /** Full mailbox path (empty string for root) */
+    path: string;
+    /** Leaf name (last segment of path) */
+    name: string;
+    /** Path delimiter from the server */
+    delimiter: string;
+    /** IMAP flags (e.g. "\\HasChildren", "\\Noselect", "\\Inbox") */
+    flags: string[];
+    /** Detected special-use tag (sent/trash/drafts/spam/archive/inbox), if known */
+    specialUse?: string;
+    /** True if the folder itself cannot be selected (e.g. "\\Noselect" flag) */
+    disabled?: boolean;
+    /** Child folders */
+    folders: FolderTreeNode[];
+}
+/** Build a nested tree from a flat folder list using path + delimiter. */
+export declare function buildFolderTree(folders: NativeFolder[]): FolderTreeNode;
+//# sourceMappingURL=folder-tree.d.ts.map

package/folder-tree.js

@@ -0,0 +1,57 @@
+/**
+ * Folder tree builder — converts a flat NativeFolder[] into a nested tree.
+ * Equivalent to imapflow's listTree(), but pure JS and transport-agnostic.
+ * Parents are derived from path + delimiter (NativeFolder has no pre-parsed parent[]).
+ */
+/** Build a nested tree from a flat folder list using path + delimiter. */
+export function buildFolderTree(folders) {
+    const delimiter = folders[0]?.delimiter || ".";
+    const root = { root: true, path: "", name: "", delimiter, flags: [], folders: [] };
+    const byPath = new Map();
+    byPath.set("", root);
+    // Sort by path so parents are created before children
+    const sorted = [...folders].sort((a, b) => a.path.localeCompare(b.path));
+    for (const f of sorted) {
+        const delim = f.delimiter || delimiter;
+        const parts = f.path.split(delim);
+        const name = parts[parts.length - 1];
+        const node = {
+            path: f.path,
+            name,
+            delimiter: delim,
+            flags: f.flags,
+            folders: [],
+        };
+        if (f.flags.some(fl => fl.toLowerCase() === "\\noselect"))
+            node.disabled = true;
+        // Find or create parent chain (handles gaps where an intermediate LIST entry is missing)
+        let parentPath = "";
+        let parent = root;
+        for (let i = 0; i < parts.length - 1; i++) {
+            parentPath = parentPath ? parentPath + delim + parts[i] : parts[i];
+            let p = byPath.get(parentPath);
+            if (!p) {
+                p = { path: parentPath, name: parts[i], delimiter: delim, flags: [], folders: [], disabled: true };
+                byPath.set(parentPath, p);
+                parent.folders.push(p);
+            }
+            parent = p;
+        }
+        const existing = byPath.get(f.path);
+        if (existing) {
+            // Fill in a placeholder that was created for a descendant
+            existing.flags = f.flags;
+            existing.name = name;
+            existing.delimiter = delim;
+            delete existing.disabled;
+            if (f.flags.some(fl => fl.toLowerCase() === "\\noselect"))
+                existing.disabled = true;
+        }
+        else {
+            byPath.set(f.path, node);
+            parent.folders.push(node);
+        }
+    }
+    return root;
+}
+//# sourceMappingURL=folder-tree.js.map

package/imap-compat.d.ts

@@ -4,6 +4,7 @@
  * Each method opens the mailbox, does the operation, and returns. No persistent state.
  */
 import { type NativeFolder } from "./imap-native.js";
+import { FetchedMessage } from "./fetched-message.js";
 import type { ImapClientConfig } from "./types.js";
 import type { TransportFactory } from "./transport.js";
 /** Special folder detection result */
@@ -36,15 +37,15 @@ export declare class CompatImapClient {
     /** Fetch messages since a UID in a mailbox */
     fetchMessagesSinceUid(mailbox: string, sinceUid: number, options?: {
         source?: boolean;
-    }): Promise<any[]>;
+    }): Promise<FetchedMessage[]>;
     /** Fetch messages by date range. Optional onChunk callback for incremental processing. */
     fetchMessageByDate(mailbox: string, start: Date, end?: Date, options?: {
         source?: boolean;
-    }, onChunk?: (msgs: any[]) => void): Promise<any[]>;
+    }, onChunk?: (msgs: FetchedMessage[]) => void): Promise<FetchedMessage[]>;
     /** Fetch a single message by UID */
     fetchMessageByUid(mailbox: string, uid: number, options?: {
         source?: boolean;
-    }): Promise<any | null>;
+    }): Promise<FetchedMessage | null>;
     /** Get message count via STATUS (does not require SELECT) */
     getMessagesCount(mailbox: string): Promise<number>;
     /** Get all UIDs in a mailbox */
@@ -59,10 +60,10 @@ export declare class CompatImapClient {
      *  used by the puller. */
     fetchMessages(mailbox: string, uidRange: string, options?: {
         source?: boolean;
-    }): Promise<any[]>;
+    }): Promise<FetchedMessage[]>;
     fetchMessages(mailbox: string, end: number, count: number, options?: {
         source?: boolean;
-    }): Promise<any[]>;
+    }): Promise<FetchedMessage[]>;
     /** Search messages in a mailbox */
     searchMessages(mailbox: string, criteria: any): Promise<number[]>;
     /** Search by header value — returns matching UIDs */

package/imap-compat.js

@@ -4,44 +4,7 @@
  * Each method opens the mailbox, does the operation, and returns. No persistent state.
  */
 import { NativeImapClient } from "./imap-native.js";
-/** Convert NativeFetchedMessage to the old FetchedMessage shape used by mailx-imap */
-function toCompatMessage(msg) {
-    return {
-        uid: msg.uid,
-        seq: msg.seq,
-        flags: msg.flags,
-        seen: msg.seen,
-        flagged: msg.flagged,
-        answered: msg.answered,
-        draft: msg.draft,
-        date: msg.date,
-        subject: msg.subject,
-        messageId: msg.messageId,
-        from: msg.from,
-        to: msg.to,
-        cc: msg.cc,
-        bcc: msg.bcc,
-        sender: msg.sender,
-        replyTo: msg.replyTo,
-        inReplyTo: msg.inReplyTo,
-        size: msg.size,
-        source: msg.source,
-        headers: msg.headers,
-        // Compatibility: old FetchedMessage had envelope sub-object, but mailx-imap accesses directly
-        envelope: {
-            date: msg.date,
-            subject: msg.subject,
-            messageId: msg.messageId,
-            from: msg.from,
-            to: msg.to,
-            cc: msg.cc,
-            bcc: msg.bcc,
-            sender: msg.sender,
-            replyTo: msg.replyTo,
-            inReplyTo: msg.inReplyTo,
-        }
-    };
-}
+import { FetchedMessage } from "./fetched-message.js";
 /**
  * Compatibility IMAP client — wraps NativeImapClient with the old ImapClient API.
  * Each method creates its own select/operation/close cycle.
@@ -128,16 +91,16 @@ export class CompatImapClient {
         await this.native.select(mailbox);
         const msgs = await this.native.fetchSinceUid(sinceUid, options);
         await this.native.closeMailbox();
-        return msgs.map(toCompatMessage);
+        return msgs.map(m => new FetchedMessage(m));
     }
     /** Fetch messages by date range. Optional onChunk callback for incremental processing. */
     async fetchMessageByDate(mailbox, start, end, options, onChunk) {
         await this.ensureConnected();
         await this.native.select(mailbox);
-        const chunkCb = onChunk ? (raw) => onChunk(raw.map(toCompatMessage)) : undefined;
+        const chunkCb = onChunk ? (raw) => onChunk(raw.map(m => new FetchedMessage(m))) : undefined;
         const msgs = await this.native.fetchByDate(start, end, options, chunkCb);
         await this.native.closeMailbox();
-        return msgs.map(toCompatMessage);
+        return msgs.map(m => new FetchedMessage(m));
     }
     /** Fetch a single message by UID */
     async fetchMessageByUid(mailbox, uid, options) {
@@ -145,7 +108,7 @@ export class CompatImapClient {
         await this.native.select(mailbox);
         const msg = await this.native.fetchMessage(uid, options);
         await this.native.closeMailbox();
-        return msg ? toCompatMessage(msg) : null;
+        return msg ? new FetchedMessage(msg) : null;
     }
     /** Get message count via STATUS (does not require SELECT) */
     async getMessagesCount(mailbox) {
@@ -180,7 +143,7 @@ export class CompatImapClient {
         await this.native.select(mailbox);
         const msgs = await this.native.fetchMessages(range, options);
         await this.native.closeMailbox();
-        return msgs.map(toCompatMessage);
+        return msgs.map(m => new FetchedMessage(m));
     }
     /** Search messages in a mailbox */
     async searchMessages(mailbox, criteria) {

package/index.d.ts

@@ -14,5 +14,8 @@ export { NativeImapClient } from "./imap-native.js";
 export type { NativeFetchedMessage, NativeFolder, MailboxInfo } from "./imap-native.js";
 export { CompatImapClient } from "./imap-compat.js";
 export type { SpecialFolders } from "./imap-compat.js";
+export { FetchedMessage } from "./fetched-message.js";
+export { buildFolderTree } from "./folder-tree.js";
+export type { FolderTreeNode } from "./folder-tree.js";
 export { isGmailUser, isGmailServer, createGmailConfig, createAutoImapConfig, type GmailOAuthConfig, } from "./gmail.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -13,6 +13,10 @@ export * as proto from "./imap-protocol.js";
 export { NativeImapClient } from "./imap-native.js";
 // Compatibility wrapper (old ImapClient API shape)
 export { CompatImapClient } from "./imap-compat.js";
+// Rich message wrapper (ported from @bobfrankston/iflow — parses headers, exposes ymd/tcsb/etc.)
+export { FetchedMessage } from "./fetched-message.js";
+// Folder tree builder (equivalent to imapflow.listTree, pure JS)
+export { buildFolderTree } from "./folder-tree.js";
 // Gmail OAuth support (Node-free — caller provides tokenProvider)
 export { isGmailUser, isGmailServer, createGmailConfig, createAutoImapConfig, } from "./gmail.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow-direct",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Direct IMAP client — transport-agnostic, no Node.js dependencies, browser-ready",
   "main": "index.js",
   "types": "index.ts",
@@ -18,6 +18,9 @@
   ],
   "author": "Bob Frankston",
   "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/tcp-transport": "^0.1.0"
+  },
   "exports": {
     ".": {
       "types": "./index.ts",
@@ -38,5 +41,13 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/BobFrankston/iflow-direct.git"
+  },
+  ".dependencies": {
+    "@bobfrankston/tcp-transport": "file:../tcp-transport"
+  },
+  ".transformedSnapshot": {
+    "dependencies": {
+      "@bobfrankston/tcp-transport": "^0.1.0"
+    }
   }
 }

package/transport.d.ts

@@ -1,25 +1,11 @@
 /**
- * Abstract transport interface for IMAP connections.
- * Implementations: NodeTransport (desktop), BridgeTransport (Android/WebView)
+ * Back-compat re-export. The TCP transport interface lives in
+ * @bobfrankston/tcp-transport — it's protocol-agnostic, used by SMTP, IMAP,
+ * and any other line-oriented TCP code.
+ *
+ * `ImapTransport` is kept as an alias for `TcpTransport` so existing callers
+ * continue to compile. New code should import `TcpTransport` directly from
+ * @bobfrankston/tcp-transport.
  */
-export interface ImapTransport {
-    /** Connect to host:port. If tls=true, connect with TLS directly (port 993). */
-    connect(host: string, port: number, tls: boolean, servername?: string): Promise<void>;
-    /** Upgrade an existing plaintext connection to TLS (STARTTLS). */
-    upgradeTLS(servername?: string): Promise<void>;
-    /** Write data to the connection. */
-    write(data: string | Uint8Array): Promise<void>;
-    /** Register a handler for incoming data. */
-    onData(handler: (data: string) => void): void;
-    /** Register a handler for connection close. */
-    onClose(handler: (hadError: boolean) => void): void;
-    /** Register a handler for errors. */
-    onError(handler: (err: Error) => void): void;
-    /** Close the connection. */
-    close(): void;
-    /** Whether the connection is active. */
-    readonly connected: boolean;
-}
-/** Factory function type for creating transports */
-export type TransportFactory = () => ImapTransport;
+export type { TcpTransport as ImapTransport, TransportFactory } from "@bobfrankston/tcp-transport";
 //# sourceMappingURL=transport.d.ts.map

package/transport.js

@@ -1,6 +1,11 @@
 /**
- * Abstract transport interface for IMAP connections.
- * Implementations: NodeTransport (desktop), BridgeTransport (Android/WebView)
+ * Back-compat re-export. The TCP transport interface lives in
+ * @bobfrankston/tcp-transport — it's protocol-agnostic, used by SMTP, IMAP,
+ * and any other line-oriented TCP code.
+ *
+ * `ImapTransport` is kept as an alias for `TcpTransport` so existing callers
+ * continue to compile. New code should import `TcpTransport` directly from
+ * @bobfrankston/tcp-transport.
  */
 export {};
 //# sourceMappingURL=transport.js.map