@bobfrankston/iflow 1.0.43 → 1.0.45

package/imaplib/imap-native.js

@@ -141,15 +141,9 @@ export class NativeImapClient {
             this.capabilities.add(c.toUpperCase());
     }
     async logout() {
-        // Send LOGOUT but don't wait — just close the transport immediately.
-        // The server will clean up the session when the socket closes.
-        try {
-            if (this._connected) {
-                const tag = proto.nextTag();
-                this.transport.write(proto.logoutCommand(tag)).catch(() => { });
-            }
-        }
-        catch { /* ignore */ }
+        // Force-close the transport immediately. The LOGOUT command is a courtesy —
+        // the server cleans up the session when the socket closes.
+        // Sending LOGOUT and waiting caused hangs and connection leaks.
         this.pendingCommand = null;
         this.transport.close();
         this._connected = false;
@@ -471,15 +465,23 @@ export class NativeImapClient {
     }
     processBuffer() {
         while (true) {
-            // Check for literal {size}\r\n
+            // Check for literal {size}\r\n — reading exact byte count of literal data
             if (this.pendingCommand?.literalBytes != null) {
                 if (this.buffer.length >= this.pendingCommand.literalBytes) {
                     const literal = this.buffer.substring(0, this.pendingCommand.literalBytes);
                     this.buffer = this.buffer.substring(this.pendingCommand.literalBytes);
                     this.pendingCommand.literalBuffer = (this.pendingCommand.literalBuffer || "") + literal;
                     this.pendingCommand.literalBytes = undefined;
+                    if (this.verbose)
+                        console.log(`  [imap] literal consumed, ${literal.length} bytes, buffer remaining: ${this.buffer.length}`);
+                    // After consuming literal, check if the NEXT part has another literal
+                    // (e.g., BODY[HEADER] {500}\r\n<data>BODY[] {2000}\r\n<data>)\r\n)
+                    // Continue to process the next line/literal from the buffer
                     continue;
                 }
+                if (this.verbose && this.pendingCommand.literalBytes > 0) {
+                    console.log(`  [imap] waiting for literal: need ${this.pendingCommand.literalBytes}, have ${this.buffer.length}`);
+                }
                 break; // Wait for more data
             }
             const lineEnd = this.buffer.indexOf("\r\n");
@@ -487,24 +489,34 @@ export class NativeImapClient {
                 break;
             const line = this.buffer.substring(0, lineEnd + 2);
             this.buffer = this.buffer.substring(lineEnd + 2);
-            // Check for literal announcement {size}
+            // Check for literal announcement {size}\r\n at end of line
             const literalMatch = line.match(/\{(\d+)\}\r\n$/);
             if (literalMatch && this.pendingCommand) {
-                this.pendingCommand.literalBytes = parseInt(literalMatch[1]);
-                // Store the line prefix before the literal
-                const linePrefix = line.substring(0, line.indexOf(`{${literalMatch[1]}}`));
-                this.pendingCommand.literalBuffer = linePrefix;
+                const size = parseInt(literalMatch[1]);
+                // Store the line prefix before {size} — will be prepended after literal is consumed
+                const linePrefix = line.substring(0, literalMatch.index);
+                if (this.pendingCommand.literalBuffer) {
+                    // Already have buffered data from a previous literal — append this prefix
+                    this.pendingCommand.literalBuffer += linePrefix;
+                }
+                else {
+                    this.pendingCommand.literalBuffer = linePrefix;
+                }
+                this.pendingCommand.literalBytes = size;
+                if (this.verbose)
+                    console.log(`  [imap] literal announced: ${size} bytes, prefix: ${linePrefix.length} chars`);
                 continue;
             }
-            // If we have buffered literal data, prepend it
+            // If we have buffered literal data, prepend it to this line (the closing part after the literal)
             let fullLine = line;
             if (this.pendingCommand?.literalBuffer) {
                 fullLine = this.pendingCommand.literalBuffer + line;
                 this.pendingCommand.literalBuffer = undefined;
             }
             const resp = proto.parseResponseLine(fullLine);
-            if (this.verbose && resp.raw.length < 200) {
-                console.log(`  [imap] < ${resp.raw}`);
+            if (this.verbose) {
+                const display = resp.raw.length > 200 ? resp.raw.substring(0, 200) + `... (${resp.raw.length} bytes)` : resp.raw;
+                console.log(`  [imap] < [tag=${resp.tag} type=${resp.type}] ${display}`);
             }
             // Server greeting — resolve readGreeting() promise
             if (this.greetingResolve && resp.tag === "*" && (resp.type === "OK" || resp.type === "PREAUTH")) {

package/imaplib/imap-protocol.js

@@ -116,8 +116,8 @@ export function parseResponseLine(line) {
     // Untagged response
     if (trimmed.startsWith("* ")) {
         const rest = trimmed.substring(2);
-        // Check for numeric response (e.g., "* 5 EXISTS")
-        const numMatch = rest.match(/^(\d+)\s+(\S+)(.*)$/);
+        // Check for numeric response (e.g., "* 5 EXISTS", "* 131441 FETCH (...)")
+        const numMatch = rest.match(/^(\d+)\s+(\S+)/);
         if (numMatch) {
             return { tag: "*", type: numMatch[2].toUpperCase(), text: rest, raw: trimmed };
         }
@@ -247,12 +247,26 @@ function decodeImapString(s) {
         return "";
     return s.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_match, charset, encoding, text) => {
         try {
+            const cs = charset.toLowerCase().replace(/^utf8$/, "utf-8");
             if (encoding.toUpperCase() === "B") {
-                return Buffer.from(text, "base64").toString("utf-8");
+                return Buffer.from(text, "base64").toString(cs);
             }
             else {
-                // Quoted-printable
-                return text.replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/_/g, " ");
+                // Quoted-printable: collect bytes then decode with charset
+                const decoded = text.replace(/_/g, " ");
+                const bytes = [];
+                let i = 0;
+                while (i < decoded.length) {
+                    if (decoded[i] === "=" && i + 2 < decoded.length) {
+                        bytes.push(parseInt(decoded.substring(i + 1, i + 3), 16));
+                        i += 3;
+                    }
+                    else {
+                        bytes.push(decoded.charCodeAt(i));
+                        i++;
+                    }
+                }
+                return Buffer.from(bytes).toString(cs);
             }
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "IMAP client wrapper library",
   "main": "index.js",
   "types": "index.ts",