@mochabug/adapt-web 0.0.39 → 0.0.42

package/dist/esm/index.js

@@ -2,8 +2,26 @@ import { fromBinary, toJson } from "@bufbuild/protobuf";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import { connect, createInbox, credsAuthenticator, JSONCodec, } from "nats.ws";
 import { OutputSchema, SessionSchema, UrlSchema, } from "./genproto/mochabugapis/adapt/automations/v1/automations_pb.js";
+// Constants for JetStream protocol
+const CONSUMER_MSG_NEXT_PREFIX = "$JS.API.CONSUMER.MSG.NEXT.";
+const ACK_POSITIVE = new TextEncoder().encode("+ACK");
+const ACK_NEGATIVE = new TextEncoder().encode("-NAK");
+//const ACK_PREFIX = "$JS.ACK.";
+//const ACK_IN_PROGRESS = new TextEncoder().encode("+WPI");
+//const ACK_TERMINATE = new TextEncoder().encode("+TERM");
+// JetStream Status Codes
+const STATUS_NO_MESSAGES = "404";
+const STATUS_REQUEST_TIMEOUT = "408";
+const STATUS_MAX_ACK_PENDING = "409";
+const STATUS_FLOW_CONTROL = "100";
+// Default configuration
+const DEFAULT_MAX_MESSAGES = 100;
+const DEFAULT_EXPIRES_MS = 30000;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_THRESHOLD_RATIO = 0.5;
 const natsUrl = "wss://adapt-dev.mochabugapis.com:443/pubsub";
 const baseUrl = "https://adapt-dev.mochabugapis.com/v1/automations";
+// REST API functions (unchanged from original)
 export async function startSession(req, token) {
     const headers = new Headers({
         "Content-Type": "application/json",
@@ -96,6 +114,7 @@ export class RestClientError extends Error {
         this.response = response;
     }
 }
+// Connection states
 var ConnectionState;
 (function (ConnectionState) {
     ConnectionState["DISCONNECTED"] = "disconnected";
@@ -104,9 +123,8 @@ var ConnectionState;
     ConnectionState["CLOSING"] = "closing";
 })(ConnectionState || (ConnectionState = {}));
 export class PubsubClient {
-    constructor() {
+    constructor(debug = false) {
         this.nc = null;
-        this.js = null;
         this.pullSubscription = null;
         this.subject = null;
         this.streamName = null;
@@ -116,100 +134,106 @@ export class PubsubClient {
         this.urlHandler = null;
         this.isReconnecting = false;
         this.connectionState = ConnectionState.DISCONNECTED;
-        this.subscribe = this.subscribe.bind(this);
-        this.unsubscribe = this.unsubscribe.bind(this);
-        this.createSubscriptions = this.createSubscriptions.bind(this);
-        this.clearSubscriptions = this.clearSubscriptions.bind(this);
-        this.resubscribe = this.resubscribe.bind(this);
-        this.setupStatusMonitoring = this.setupStatusMonitoring.bind(this);
-        this.isConnected = this.isConnected.bind(this);
-        this.getConnectionState = this.getConnectionState.bind(this);
+        // Pull consumer state
+        this.pending = 0;
+        this.pulling = false;
+        this.pullTimer = null;
+        this.maxMessages = DEFAULT_MAX_MESSAGES;
+        this.expiresMs = DEFAULT_EXPIRES_MS;
+        this.pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+        this.threshold = DEFAULT_MAX_MESSAGES * DEFAULT_THRESHOLD_RATIO;
+        this.inbox = null;
+        this.jc = JSONCodec();
+        this.debug = debug;
+    }
+    log(level, message, data) {
+        if (!this.debug && level === "debug")
+            return;
+        const prefix = `[PubSub]`;
+        const fullMessage = `${prefix} ${message}`;
+        if (data !== undefined) {
+            console[level](fullMessage, data);
+        }
+        else {
+            console[level](fullMessage);
+        }
     }
     async subscribe(opts) {
-        console.info("[PubSub] Subscribe called with:", {
+        this.log("info", "Subscribe called with:", {
             subject: opts.subject,
             consumer: opts.consumer,
             stream: opts.stream,
         });
         // Validate inputs
         if (!validateSubject(opts.subject)) {
-            throw new Error(`[PubSub] Invalid subject: "${opts.subject}"`);
+            throw new Error(`Invalid subject: "${opts.subject}"`);
         }
         if (!opts.consumer || !opts.stream) {
-            throw new Error("[PubSub] Consumer and stream names are required");
+            throw new Error("Consumer and stream names are required");
         }
         // If we're already connected to the same subject, just update handlers
         if (this.connectionState === ConnectionState.CONNECTED &&
             this.subject === opts.subject &&
-            this.nc &&
-            !this.nc.isClosed()) {
-            console.info("[PubSub] Already connected to same subject, updating handlers only");
+            this.streamName === opts.stream &&
+            this.consumerName === opts.consumer) {
+            this.log("debug", "Already connected to same subject, updating handlers only");
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
             this.urlHandler = opts.onUrl || null;
             return;
         }
         if (this.connectionState === ConnectionState.CONNECTING) {
-            throw new Error("[PubSub] Already connecting, please wait");
+            throw new Error("Already connecting, please wait");
         }
-        // If connected to a different subject or need to reconnect, close first
+        // If connected to a different subject, close first
         if (this.connectionState === ConnectionState.CONNECTED ||
             this.connectionState === ConnectionState.CLOSING) {
-            console.info("[PubSub] Closing existing connection before new subscription");
             await this.unsubscribe();
         }
         try {
             this.connectionState = ConnectionState.CONNECTING;
-            // Store the new configuration
+            // Store configuration
             this.subject = opts.subject;
             this.streamName = opts.stream;
             this.consumerName = opts.consumer;
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
             this.urlHandler = opts.onUrl || null;
-            // Create authenticator
+            this.maxMessages = opts.maxMessages || DEFAULT_MAX_MESSAGES;
+            this.expiresMs = opts.expiresMs || DEFAULT_EXPIRES_MS;
+            this.pollIntervalMs = opts.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+            this.threshold = Math.floor(this.maxMessages * DEFAULT_THRESHOLD_RATIO);
+            // Connect to NATS
             const inboxPrefix = `_INBOX_${opts.consumer}`;
-            console.info(`[PubSub] Connecting to NATS with inbox prefix: ${inboxPrefix}`);
+            this.log("debug", `Connecting with inbox prefix: ${inboxPrefix}`);
             this.nc = await connect({
                 servers: [natsUrl],
                 authenticator: createAuthenticator(opts.credentials),
-                inboxPrefix: inboxPrefix, // This ensures inbox isolation
+                inboxPrefix: inboxPrefix,
                 reconnect: true,
                 noEcho: true,
                 maxReconnectAttempts: -1,
                 reconnectTimeWait: 1000,
                 pingInterval: 10 * 1000,
             });
-            // Get JetStream context
-            this.js = this.nc.jetstream();
-            // Connection successful
             this.connectionState = ConnectionState.CONNECTED;
-            console.info("[PubSub] Connected successfully with JetStream");
-            // Set up status monitoring
+            this.log("info", "Connected successfully");
             this.setupStatusMonitoring();
-            // Create JetStream consumer subscription
-            await this.createSubscriptions(this.streamName, this.consumerName);
+            await this.createPullSubscription();
         }
         catch (error) {
             this.connectionState = ConnectionState.DISCONNECTED;
-            // Clean up on error
-            this.subject = null;
-            this.streamName = null;
-            this.consumerName = null;
-            this.outputHandler = null;
-            this.sessionHandler = null;
-            this.urlHandler = null;
-            this.js = null;
+            this.cleanupState();
             if (this.nc) {
                 try {
                     await this.nc.close();
                 }
                 catch (closeError) {
-                    console.error("[PubSub] Error closing connection after failed subscribe:", closeError);
+                    this.log("error", "Error closing connection after failed subscribe:", closeError);
                 }
                 this.nc = null;
             }
-            console.error("[PubSub] Failed to subscribe:", error);
+            this.log("error", "Failed to subscribe:", error);
             throw error;
         }
     }
@@ -221,10 +245,10 @@ export class PubsubClient {
                 for await (const status of this.nc.status()) {
                     switch (status.type) {
                         case "disconnect":
-                            console.warn("[PubSub] ⚠ Disconnected", { data: status.data });
+                            this.log("warn", "⚠ Disconnected", { data: status.data });
                             break;
                         case "reconnect":
-                            console.info("[PubSub] ↻ Reconnected");
+                            this.log("info", "↻ Reconnected");
                             if (!this.isReconnecting &&
                                 this.connectionState === ConnectionState.CONNECTED) {
                                 this.isReconnecting = true;
@@ -232,7 +256,7 @@ export class PubsubClient {
                                     await this.resubscribe();
                                 }
                                 catch (error) {
-                                    console.error("[PubSub] Failed to resubscribe after reconnection:", error);
+                                    this.log("error", "Failed to resubscribe after reconnection:", error);
                                 }
                                 finally {
                                     this.isReconnecting = false;
@@ -240,284 +264,344 @@ export class PubsubClient {
                             }
                             break;
                         case "error":
-                            // Usually permissions errors
-                            console.error("[PubSub] Connection error:", status.data);
+                            this.log("error", "Connection error:", status.data);
                             break;
                         case "update":
-                            // Cluster configuration update
-                            console.info("[PubSub] Cluster update received:", status.data);
+                            this.log("debug", "Cluster update received:", status.data);
                             break;
                         case "ldm":
-                            // Lame Duck Mode - server is requesting clients to reconnect
-                            console.warn("[PubSub] Server requesting reconnection (LDM)");
+                            this.log("warn", "Server requesting reconnection (LDM)");
                             break;
-                        // Debug events - usually can be safely ignored but useful for debugging
                         case "reconnecting":
-                            console.debug("[PubSub] Attempting to reconnect...");
-                            break;
-                        case "pingTimer":
-                            // Ping timer events - very verbose, only log if needed
-                            // console.debug("[PubSub] Ping timer event");
+                            this.log("debug", "Attempting to reconnect...");
                             break;
                         case "staleConnection":
-                            console.warn("[PubSub] Connection is stale, may reconnect soon");
+                            this.log("warn", "Connection is stale, may reconnect soon");
                             break;
                         default:
-                            console.debug(`[PubSub] Unknown status event: ${status.type}`, status.data);
+                            if (status.type !== "pingTimer" || this.debug) {
+                                this.log("debug", `Status event: ${status.type}`, status.data);
+                            }
                     }
                 }
             }
             catch (error) {
                 if (this.connectionState !== ConnectionState.CLOSING) {
-                    console.error("[PubSub] Fatal status handler error:", error);
+                    this.log("error", "Fatal status handler error:", error);
                 }
             }
         })();
     }
-    async createSubscriptions(streamName, consumerName) {
-        if (!this.nc || !this.js) {
-            console.error("[PubSub] Cannot create subscriptions - no connection");
-            return;
-        }
-        if (!this.subject) {
-            console.error("[PubSub] Cannot create subscriptions - no subject");
-            return;
-        }
-        if (this.nc.isClosed()) {
-            console.error("[PubSub] Cannot create subscriptions - connection is closed");
-            return;
+    async createPullSubscription() {
+        if (!this.nc || !this.streamName || !this.consumerName) {
+            throw new Error("Not properly initialized");
         }
         await this.clearSubscriptions();
         try {
-            console.info(`[PubSub] Creating pull subscription for consumer: ${consumerName} on stream: ${streamName}`);
-            const jc = JSONCodec();
-            const pullSubject = `$JS.API.CONSUMER.MSG.NEXT.${streamName}.${consumerName}`;
-            // Create inbox with proper prefix - let NATS generate the unique part
-            const inbox = createInbox(`_INBOX_${consumerName}`);
-            const sub = this.nc.subscribe(inbox);
+            this.log("info", `Creating pull subscription for consumer: ${this.consumerName} on stream: ${this.streamName}`);
+            // Create inbox for receiving messages
+            this.inbox = createInbox(`_INBOX_${this.consumerName}`);
+            const sub = this.nc.subscribe(this.inbox);
             this.pullSubscription = sub;
-            // Track state
-            let pending = 0;
-            let pulling = false;
-            const maxMessages = 100;
-            const threshold = 50;
-            const pollInterval = 1000; // 1 second poll interval
-            // Pull messages with proper expiration
-            const pull = async (batch) => {
-                if (pulling || !this.nc || this.nc.isClosed())
-                    return;
-                pulling = true;
+            // Reset state
+            this.pending = 0;
+            this.pulling = false;
+            // Start message processing loop
+            this.processMessages(sub);
+            // Initial pull - use no_wait to check for immediate messages
+            this.log("debug", `Initial no_wait pull for ${this.maxMessages} messages`);
+            await this.pull(this.maxMessages, true);
+            // Schedule periodic pulls for long polling
+            this.schedulePull();
+            this.log("info", "Pull subscription created successfully");
+        }
+        catch (error) {
+            this.log("error", "Failed to create subscriptions:", error);
+            throw error;
+        }
+    }
+    async processMessages(sub) {
+        try {
+            for await (const msg of sub) {
+                if (this.connectionState === ConnectionState.CLOSING ||
+                    this.connectionState === ConnectionState.DISCONNECTED) {
+                    this.log("info", "Subscription closing");
+                    break;
+                }
                 try {
-                    // Set expires to slightly longer than poll interval to avoid accumulation
-                    const request = {
-                        batch,
-                        expires: (pollInterval + 500) * 1000000, // Poll interval + 500ms buffer, in nanoseconds
-                    };
-                    this.nc.publish(pullSubject, jc.encode(request), { reply: inbox });
-                    pending += batch;
+                    await this.handleMessage(msg);
                 }
-                finally {
-                    pulling = false;
+                catch (error) {
+                    this.log("error", "Error handling message:", error);
                 }
-            };
-            // Initial pull
-            pull(maxMessages);
-            // Set up periodic pulling
-            let pullTimer = null;
-            const schedulePull = () => {
-                if (pullTimer)
-                    clearTimeout(pullTimer);
-                pullTimer = setTimeout(() => {
-                    if (pending < threshold) {
-                        pull(maxMessages - pending);
-                    }
-                }, pollInterval);
-            };
-            // Process messages
-            (async () => {
-                try {
-                    for await (const msg of sub) {
-                        if (this.connectionState === ConnectionState.CLOSING ||
-                            this.connectionState === ConnectionState.DISCONNECTED) {
-                            console.info("[PubSub] Subscription closing");
-                            if (pullTimer)
-                                clearTimeout(pullTimer);
-                            break;
-                        }
-                        // Check status header
-                        const status = msg.headers?.get("Status");
-                        if (status === "404") {
-                            // No messages available
-                            console.debug("[PubSub] No messages available (404)");
-                            pending = 0;
-                            schedulePull();
-                            continue;
-                        }
-                        if (status === "408") {
-                            console.debug("[PubSub] Pull request timed out (408)");
-                            pending = 0;
-                            schedulePull();
-                            continue;
-                        }
-                        if (status === "409") {
-                            console.warn("[PubSub] Max ack pending reached (409)");
-                            pending = 0;
-                            setTimeout(() => pull(maxMessages), 5000);
-                            continue;
-                        }
-                        // Skip if not a real message
-                        if (!msg.data || msg.data.length === 0 || msg.subject === inbox) {
-                            continue;
-                        }
-                        // We got a real message
-                        pending = Math.max(0, pending - 1);
-                        // Re-pull if below threshold
-                        if (pending < threshold && !pulling) {
-                            pull(maxMessages - pending);
-                        }
-                        const parts = msg.subject.split(".");
-                        const action = parts[parts.length - 1];
-                        console.info(`[PubSub] ↓ message: ${action} on ${msg.subject}`);
-                        try {
-                            switch (action) {
-                                case "output": {
-                                    if (this.outputHandler) {
-                                        const output = fromBinary(OutputSchema, msg.data);
-                                        this.outputHandler({
-                                            vertex: output.vertex,
-                                            fork: output.fork,
-                                            data: parseOutputData(output.data),
-                                            created: timestampDate(output.created),
-                                        });
-                                    }
-                                    break;
-                                }
-                                case "session": {
-                                    if (this.sessionHandler) {
-                                        const session = fromBinary(SessionSchema, msg.data);
-                                        this.sessionHandler(toJson(SessionSchema, session));
-                                    }
-                                    break;
-                                }
-                                case "url": {
-                                    if (this.urlHandler) {
-                                        const url = fromBinary(UrlSchema, msg.data);
-                                        this.urlHandler(toJson(UrlSchema, url));
-                                    }
-                                    break;
-                                }
-                                default:
-                                    console.warn("[PubSub] Unknown message action:", action);
-                            }
-                            if (msg.reply) {
-                                msg.respond();
-                            }
-                        }
-                        catch (error) {
-                            console.error("[PubSub] Error handling message:", error);
-                            if (msg.reply) {
-                                msg.respond(new TextEncoder().encode("-NAK"));
-                            }
-                        }
+            }
+        }
+        catch (error) {
+            if (this.connectionState !== ConnectionState.CLOSING) {
+                this.log("error", "Message processing error:", error);
+            }
+        }
+    }
+    async handleMessage(msg) {
+        this.log("debug", "header", msg.headers);
+        const status = msg.headers?.get("Status");
+        const description = msg.headers?.get("Description");
+        if (status) {
+            this.log("debug", `Received status message: ${status} ${description || ""}`);
+            await this.handleStatusMessage(status, description, msg);
+            return;
+        }
+        // Check for flow control messages (also may have empty data)
+        const flowControl = msg.headers?.get("Nats-Msg-Size");
+        if (flowControl === "FlowControl") {
+            this.log("debug", "Received flow control request, responding");
+            msg.respond();
+            return;
+        }
+        // Alternative flow control check
+        if (msg.headers) {
+            const headers = Array.from(msg.headers.keys());
+            if (headers.some((h) => h.includes("FlowControl"))) {
+                this.log("debug", "Received flow control message, responding");
+                if (msg.reply) {
+                    msg.respond();
+                }
+                return;
+            }
+        }
+        // Now check if this is an actual data message
+        // Status and flow control messages will have already been handled above
+        if (!msg.data || msg.data.length === 0) {
+            // This should be rare now - log with more detail for debugging
+            this.log("debug", `Received empty message on ${msg.subject}, headers: ${msg.headers ? Array.from(msg.headers.keys()).join(", ") : "none"}`);
+            return;
+        }
+        // Get the actual stream subject from headers
+        const streamSubject = msg.headers?.get("Nats-Subject");
+        if (!streamSubject) {
+            this.log("debug", "Message without stream subject, skipping");
+            return;
+        }
+        // We got a real message
+        this.pending = Math.max(0, this.pending - 1);
+        this.log("debug", `Message received on subject ${streamSubject}, pending decreased to ${this.pending}`);
+        // Process the message
+        const parts = streamSubject.split(".");
+        const action = parts[parts.length - 1];
+        this.log("info", `↓ message: ${action} on ${streamSubject}`);
+        try {
+            switch (action) {
+                case "output": {
+                    if (this.outputHandler) {
+                        const output = fromBinary(OutputSchema, msg.data);
+                        this.outputHandler({
+                            vertex: output.vertex,
+                            fork: output.fork,
+                            data: parseOutputData(output.data),
+                            created: timestampDate(output.created),
+                        });
                     }
+                    break;
                 }
-                catch (error) {
-                    if (this.connectionState !== ConnectionState.CLOSING) {
-                        console.error("[PubSub] Handler error:", error);
+                case "session": {
+                    if (this.sessionHandler) {
+                        const session = fromBinary(SessionSchema, msg.data);
+                        this.sessionHandler(toJson(SessionSchema, session));
                     }
+                    break;
                 }
-                finally {
-                    if (pullTimer)
-                        clearTimeout(pullTimer);
+                case "url": {
+                    if (this.urlHandler) {
+                        const url = fromBinary(UrlSchema, msg.data);
+                        this.urlHandler(toJson(UrlSchema, url));
+                    }
+                    break;
                 }
-            })();
-            console.info("[PubSub] Pull subscription created successfully");
+                default:
+                    this.log("warn", `Unknown message action: ${action}`);
+            }
+            // ACK the message
+            if (msg.reply) {
+                msg.respond(ACK_POSITIVE);
+                this.log("debug", `Message ACKed successfully for action: ${action}`);
+            }
         }
         catch (error) {
-            console.error("[PubSub] Failed to create subscriptions:", error);
+            this.log("error", "Error processing message:", error);
+            // NAK the message for redelivery
+            if (msg.reply) {
+                msg.respond(ACK_NEGATIVE);
+                this.log("debug", "Message NAKed for redelivery");
+            }
             throw error;
         }
+        // Pull more if below threshold
+        if (this.pending < this.threshold && !this.pulling) {
+            const pullCount = this.maxMessages - this.pending;
+            this.log("debug", `Pending ${this.pending} < threshold ${this.threshold}, pulling ${pullCount} more messages`);
+            this.pull(pullCount, false);
+        }
     }
-    async clearSubscriptions() {
-        if (this.pullSubscription) {
-            console.info("[PubSub] Clearing subscription");
-            try {
-                this.pullSubscription.unsubscribe();
-                console.info("[PubSub] ✓ Subscription cleared");
-            }
-            catch (error) {
-                console.error("[PubSub] Error clearing subscription:", error);
-            }
-            this.pullSubscription = null;
+    async handleStatusMessage(status, description, msg) {
+        switch (status) {
+            case STATUS_NO_MESSAGES:
+                this.log("debug", `No messages available (404): ${description || "No Messages"}`);
+                this.pending = 0;
+                // This is expected when using no_wait or when there are no messages
+                // Don't immediately pull again, let the scheduler handle it
+                break;
+            case STATUS_REQUEST_TIMEOUT:
+                this.log("debug", `Pull request expired (408): ${description || "Request Timeout"}`);
+                // This can happen for each unfilled slot in a batch
+                // Decrement pending for each 408 received
+                if (this.pending > 0) {
+                    this.pending--;
+                }
+                // Don't immediately pull, let threshold logic handle it
+                if (this.pending < this.threshold && !this.pulling) {
+                    await this.pull(this.maxMessages - this.pending, false);
+                }
+                break;
+            case STATUS_MAX_ACK_PENDING:
+                this.log("warn", `Max ack pending reached (409): ${description || "Exceeded MaxAckPending"}`);
+                this.pending = 0;
+                // Wait before retry
+                setTimeout(() => this.pull(this.maxMessages, false), 5000);
+                break;
+            case STATUS_FLOW_CONTROL:
+                this.log("debug", `Received heartbeat/flow control (100): ${description || ""}`);
+                // Respond if needed
+                if (msg.reply) {
+                    msg.respond();
+                }
+                break;
+            default:
+                this.log("debug", `Received unknown status: ${status} - ${description || ""}`);
         }
     }
-    async resubscribe() {
-        if (!this.subject ||
-            !this.streamName ||
-            !this.consumerName ||
-            (!this.outputHandler && !this.sessionHandler && !this.urlHandler)) {
-            console.info("[PubSub] No handlers or config configured, skipping resubscribe");
+    async pull(batch, noWait = false) {
+        if (this.pulling || !this.nc || !this.inbox || batch <= 0) {
+            this.log("debug", `Skipping pull: pulling=${this.pulling}, batch=${batch}`);
             return;
         }
+        this.pulling = true;
         try {
-            await this.createSubscriptions(this.streamName, this.consumerName);
-            console.info("[PubSub] ✓ Resubscribed successfully");
+            const pullSubject = `${CONSUMER_MSG_NEXT_PREFIX}${this.streamName}.${this.consumerName}`;
+            const request = {
+                batch,
+            };
+            if (noWait) {
+                request.no_wait = true;
+            }
+            else if (this.expiresMs > 0) {
+                // Convert milliseconds to nanoseconds
+                request.expires = this.expiresMs * 1000000;
+            }
+            this.nc.publish(pullSubject, this.jc.encode(request), {
+                reply: this.inbox,
+            });
+            this.pending += batch;
+            this.log("debug", `Pull request sent: batch=${batch}, pending=${this.pending}, noWait=${noWait}, expires=${request.expires ? `${this.expiresMs}ms` : "none"}`);
         }
         catch (error) {
-            console.error("[PubSub] Resubscription failed:", error);
+            this.log("error", "Error sending pull request:", error);
             throw error;
         }
+        finally {
+            this.pulling = false;
+        }
     }
-    async unsubscribe() {
-        if (this.connectionState === ConnectionState.DISCONNECTED) {
-            console.info("[PubSub] Already disconnected");
+    schedulePull() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+        }
+        if (this.connectionState !== ConnectionState.CONNECTED) {
             return;
         }
-        if (this.connectionState === ConnectionState.CLOSING) {
-            console.info("[PubSub] Already closing");
+        this.pullTimer = setTimeout(() => {
+            if (this.pending < this.threshold && !this.pulling) {
+                const pullCount = this.maxMessages - this.pending;
+                this.log("debug", `Scheduled pull: pending=${this.pending} < threshold=${this.threshold}, pulling ${pullCount} more`);
+                // For scheduled pulls, use long polling (with expires)
+                this.pull(pullCount, false);
+            }
+            else {
+                this.log("debug", `Skipping scheduled pull: pending=${this.pending} >= threshold=${this.threshold} or pulling=${this.pulling}`);
+            }
+            // Reschedule
+            this.schedulePull();
+        }, this.pollIntervalMs);
+    }
+    async clearSubscriptions() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+            this.pullTimer = null;
+        }
+        if (!this.pullSubscription)
             return;
+        this.log("debug", "Clearing subscription");
+        try {
+            this.pullSubscription.unsubscribe();
+            this.log("debug", "✓ Subscription cleared");
         }
-        console.info("[PubSub] Starting unsubscribe process");
-        this.connectionState = ConnectionState.CLOSING;
-        // Clear subscriptions first
-        await this.clearSubscriptions();
-        // Clear handlers
-        this.outputHandler = null;
-        this.sessionHandler = null;
-        this.urlHandler = null;
+        catch (error) {
+            this.log("error", "Error clearing subscription:", error);
+        }
+        this.pullSubscription = null;
+    }
+    async resubscribe() {
+        if (!this.streamName || !this.consumerName)
+            return;
+        this.log("info", "Resubscribing after reconnection");
+        // Clear old state
+        this.pending = 0;
+        this.pulling = false;
+        // Recreate subscription
+        await this.createPullSubscription();
+        this.log("info", "✓ Resubscribed successfully");
+    }
+    cleanupState() {
         this.subject = null;
         this.streamName = null;
         this.consumerName = null;
+        this.outputHandler = null;
+        this.sessionHandler = null;
+        this.urlHandler = null;
+        this.inbox = null;
+        this.pending = 0;
+        this.pulling = false;
+    }
+    async unsubscribe() {
+        if (this.connectionState === ConnectionState.DISCONNECTED ||
+            this.connectionState === ConnectionState.CLOSING) {
+            return;
+        }
+        this.log("info", "Starting unsubscribe process");
+        this.connectionState = ConnectionState.CLOSING;
+        await this.clearSubscriptions();
+        this.cleanupState();
         this.isReconnecting = false;
-        this.js = null;
-        // Close connection
-        if (this.nc) {
+        if (this.nc && !this.nc.isClosed()) {
             try {
-                if (!this.nc.isClosed()) {
-                    await this.nc.close();
-                    console.info("[PubSub] Connection closed");
-                }
+                await this.nc.close();
+                this.log("debug", "Connection closed");
             }
             catch (error) {
-                console.error("[PubSub] Error closing connection:", error);
-            }
-            finally {
-                this.nc = null;
+                this.log("error", "Error closing connection:", error);
             }
         }
+        this.nc = null;
         this.connectionState = ConnectionState.DISCONNECTED;
-        console.info("[PubSub] Unsubscribed successfully");
+        this.log("info", "Unsubscribed successfully");
     }
-    // Helper method to check connection status
     isConnected() {
-        return (this.connectionState === ConnectionState.CONNECTED &&
-            this.nc !== null &&
-            !this.nc.isClosed());
+        return this.connectionState === ConnectionState.CONNECTED;
     }
     getConnectionState() {
         return this.connectionState;
     }
 }
+// Helper functions
 function validateSubject(subject) {
     if (!subject || subject.includes(" ") || subject.includes("\t")) {
         return false;
@@ -535,7 +619,7 @@ function parseOutputData(data) {
             return [key, JSON.parse(new TextDecoder().decode(value))];
         }
         catch (error) {
-            console.error(`[PubSub] Failed to parse data for key ${key}:`, error);
+            console.error(`Failed to parse data for key ${key}:`, error);
             return [key, null];
         }
     }));
@@ -551,4 +635,19 @@ function createAuthenticator(val) {
         throw new Error("Invalid credentials format");
     }
 }
+// Usage example
+export async function createPubsubClient(credentials, automation, handlers, options) {
+    const client = new PubsubClient(options?.debug);
+    await client.subscribe({
+        credentials,
+        subject: `automations.${automation.organization}.${automation.group}.${automation.automation}.>`,
+        stream: "automations",
+        consumer: `${automation.automation}-consumer`,
+        onOutput: handlers.onOutput,
+        onSession: handlers.onSession,
+        onUrl: handlers.onUrl,
+        ...options,
+    });
+    return client;
+}
 //# sourceMappingURL=index.js.map