@mochabug/adapt-web 0.0.61 → 0.0.64

package/dist/esm/index.js

@@ -1,19 +1,27 @@
 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_NEGATIVE = new TextEncoder().encode("-NAK");
-// JetStream Status Codes
-const STATUS_NO_MESSAGES = 404;
-const STATUS_REQUEST_TIMEOUT = 408;
-const STATUS_MAX_ACK_PENDING = 409;
-const STATUS_FLOW_CONTROL = 100;
+import WebSocket from "isomorphic-ws";
+import { parse as parseUuid } from "uuid";
+import { SessionSchema, UrlSchema, WebsocketMessageSchema, } from "./genproto/mochabugapis/adapt/automations/v1/automations_pb.js";
 // Default configuration
-const MESSAGE_BATCH_SIZE = 10;
-const natsUrl = "wss://adapt-dev.mochabugapis.com:443/pubsub";
-const baseUrl = "https://adapt-dev.mochabugapis.com/v1/automations";
+const defaultConfig = {
+    baseUrl: "https://adapt-dev.mochabugapis.com/v1/automations",
+    wsBaseUrl: "wss://adapt-dev.mochabugapis.com/v1/automations",
+};
+// Global configuration
+let globalConfig = { ...defaultConfig };
+// Configure the Adapt client
+export function configure(config) {
+    globalConfig = { ...globalConfig, ...config };
+}
+// Get current configuration
+export function getConfig() {
+    return { ...globalConfig };
+}
+// Reset to default configuration
+export function resetConfig() {
+    globalConfig = { ...defaultConfig };
+}
 // REST API functions
 export async function startSession(req, token) {
     const headers = new Headers({
@@ -23,7 +31,7 @@ export async function startSession(req, token) {
     if (token) {
         headers.set("Authorization", `Bearer ${token}`);
     }
-    const response = await fetch(`${baseUrl}/${req.automation.organization}/${req.automation.group}/${req.automation.automation}/start`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${req.automation.organization}/${req.automation.group}/${req.automation.automation}/start`, {
         method: "POST",
         body: JSON.stringify(req),
         headers,
@@ -34,7 +42,7 @@ export async function startSession(req, token) {
     return await response.json();
 }
 export async function inheritSession(automation, sessionToken) {
-    const response = await fetch(`${baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/inherit`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/inherit`, {
         method: "POST",
         body: JSON.stringify(automation),
         headers: {
@@ -49,7 +57,7 @@ export async function inheritSession(automation, sessionToken) {
     return await response.json();
 }
 export async function getSession(automation, sessionToken) {
-    const response = await fetch(`${baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/status`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/status`, {
         method: "GET",
         headers: {
             "Response-Type": "application/json",
@@ -62,7 +70,7 @@ export async function getSession(automation, sessionToken) {
     return await response.json();
 }
 export async function readOutput(automation, sessionToken) {
-    const response = await fetch(`${baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/output`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/output`, {
         method: "GET",
         headers: {
             "Response-Type": "application/json",
@@ -75,7 +83,7 @@ export async function readOutput(automation, sessionToken) {
     return await response.json();
 }
 export async function readUrls(automation, sessionToken) {
-    const response = await fetch(`${baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/urls`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/urls`, {
         method: "GET",
         headers: {
             "Response-Type": "application/json",
@@ -88,7 +96,7 @@ export async function readUrls(automation, sessionToken) {
     return await response.json();
 }
 export async function stopSession(automation, sessionToken) {
-    const response = await fetch(`${baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/stop`, {
+    const response = await fetch(`${globalConfig.baseUrl}/${automation.organization}/${automation.group}/${automation.automation}/session/stop`, {
         method: "DELETE",
         headers: {
             Authorization: `Bearer ${sessionToken}`,
@@ -117,19 +125,19 @@ var ConnectionState;
 })(ConnectionState || (ConnectionState = {}));
 export class PubsubClient {
     constructor(debug = false) {
-        this.nc = null;
-        this.subscription = null;
-        this.streamName = null;
-        this.consumerName = null;
+        this.ws = null;
+        this.sessionToken = null;
+        this.automation = null;
         this.outputHandler = null;
         this.sessionHandler = null;
         this.urlHandler = null;
-        this.isReconnecting = false;
-        this.inbox = null;
         this.connectionState = ConnectionState.DISCONNECTED;
-        this.jc = JSONCodec();
-        // Pull consumer state
-        this.pending = 0;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = -1; // -1 = infinite
+        this.reconnectTimeWait = 1000; // Start with 1 second
+        this.maxReconnectTimeWait = 30000; // Max 30 seconds
+        this.shouldReconnect = true;
+        this.ackedMessages = new Map(); // Track ACKed messages with timestamp to prevent duplicate processing
         this.debug = debug;
     }
     log(level, message, data) {
@@ -146,17 +154,19 @@ export class PubsubClient {
     }
     async subscribe(opts) {
         this.log("debug", "Subscribe called with:", {
-            consumer: opts.consumer,
-            stream: opts.stream,
+            automation: opts.automation,
+            hasToken: !!opts.sessionToken,
         });
-        if (!opts.consumer || !opts.stream) {
-            throw new Error("Consumer and stream names are required");
+        if (!opts.sessionToken || !opts.automation) {
+            throw new Error("Session token and automation are required");
         }
-        // Only update the handlers if we stay on the same consumer and stream
+        // Only update the handlers if we stay on the same session
         if (this.connectionState === ConnectionState.CONNECTED &&
-            this.streamName === opts.stream &&
-            this.consumerName === opts.consumer) {
-            this.log("debug", "Already connected to same subject, updating handlers only");
+            this.sessionToken === opts.sessionToken &&
+            this.automation?.organization === opts.automation.organization &&
+            this.automation?.group === opts.automation.group &&
+            this.automation?.automation === opts.automation.automation) {
+            this.log("debug", "Already connected to same session, updating handlers only");
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
             this.urlHandler = opts.onUrl || null;
@@ -165,329 +175,181 @@ export class PubsubClient {
         if (this.connectionState === ConnectionState.CONNECTING) {
             throw new Error("Already connecting, please wait");
         }
-        // If already connected, let's ubsubscribe first
+        // If already connected, unsubscribe first
         if (this.connectionState === ConnectionState.CONNECTED) {
             await this.unsubscribe();
         }
+        // Store configuration
+        this.sessionToken = opts.sessionToken;
+        this.automation = opts.automation;
+        this.outputHandler = opts.onOutput || null;
+        this.sessionHandler = opts.onSession || null;
+        this.urlHandler = opts.onUrl || null;
+        this.shouldReconnect = true;
+        this.reconnectAttempts = 0;
+        this.reconnectTimeWait = 1000;
+        await this.connect();
+    }
+    async connect() {
+        if (!this.sessionToken || !this.automation) {
+            throw new Error("Session token and automation are required");
+        }
         try {
             this.connectionState = ConnectionState.CONNECTING;
-            // Store configuration
-            this.streamName = opts.stream;
-            this.consumerName = opts.consumer;
-            this.outputHandler = opts.onOutput || null;
-            this.sessionHandler = opts.onSession || null;
-            this.urlHandler = opts.onUrl || null;
-            // Connect to NATS
-            const inboxPrefix = `_INBOX_${opts.consumer}`;
-            this.log("debug", `Connecting with inbox prefix: ${inboxPrefix}`);
-            this.nc = await connect({
-                servers: [natsUrl],
-                authenticator: createAuthenticator(opts.credentials),
-                inboxPrefix: inboxPrefix,
-                reconnect: true,
-                noEcho: true,
-                maxReconnectAttempts: -1,
-                reconnectTimeWait: 1000,
-                pingInterval: 10 * 1000,
-            });
-            this.connectionState = ConnectionState.CONNECTED;
-            this.log("info", "Connected successfully");
-            this.setupStatusMonitoring();
-            await this.createPullSubscription();
-        }
-        catch (error) {
-            this.connectionState = ConnectionState.DISCONNECTED;
-            this.cleanupState();
-            if (this.nc) {
-                try {
-                    await this.nc.close();
-                }
-                catch (closeError) {
-                    this.log("error", "Error closing connection after failed subscribe:", closeError);
-                }
-                this.nc = null;
-            }
-            this.log("error", "Failed to subscribe:", error);
-            throw error;
-        }
-    }
-    setupStatusMonitoring() {
-        if (!this.nc)
-            return;
-        (async () => {
-            try {
-                for await (const status of this.nc.status()) {
-                    switch (status.type) {
-                        case "disconnect":
-                            this.log("warn", "⚠ Disconnected", { data: status.data });
-                            break;
-                        case "reconnect":
-                            this.log("info", "↻ Reconnected");
-                            if (!this.isReconnecting &&
-                                this.connectionState === ConnectionState.CONNECTED) {
-                                this.isReconnecting = true;
-                                try {
-                                    await this.resubscribe();
-                                }
-                                catch (error) {
-                                    this.log("error", "Failed to resubscribe after reconnection:", error);
-                                }
-                                finally {
-                                    this.isReconnecting = false;
-                                }
-                            }
-                            break;
-                        case "error":
-                            this.log("error", "Connection error:", status.data);
-                            break;
-                        case "update":
-                            this.log("debug", "Cluster update received:", status.data);
-                            break;
-                        case "ldm":
-                            this.log("warn", "Server requesting reconnection (LDM)");
-                            break;
-                        case "reconnecting":
-                            this.log("debug", "Attempting to reconnect...");
-                            break;
-                        case "staleConnection":
-                            this.log("warn", "Connection is stale, may reconnect soon");
-                            break;
-                        default:
-                            if (status.type !== "pingTimer" || this.debug) {
-                                this.log("debug", `Status event: ${status.type}`, status.data);
-                            }
-                    }
+            const wsUrl = `${globalConfig.wsBaseUrl}/${this.automation.organization}/${this.automation.group}/${this.automation.automation}/ws?token=${encodeURIComponent(this.sessionToken)}`;
+            this.log("info", `Connecting to WebSocket: ${wsUrl}`);
+            this.ws = new WebSocket(wsUrl);
+            this.ws.binaryType = "arraybuffer";
+            this.ws.onopen = () => {
+                this.log("info", "✓ WebSocket connected");
+                this.connectionState = ConnectionState.CONNECTED;
+            };
+            this.ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+            this.ws.onerror = (error) => {
+                this.log("error", "WebSocket error:", error);
+            };
+            this.ws.onclose = (event) => {
+                this.log("info", `WebSocket closed: ${event.code} - ${event.reason}`);
+                this.connectionState = ConnectionState.DISCONNECTED;
+                // Handle different close codes
+                switch (event.code) {
+                    case 1000: // Normal closure (server closed friendly)
+                        this.log("info", "Normal WebSocket closure");
+                        this.shouldReconnect = false;
+                        this.unsubscribe().catch((error) => {
+                            this.log("error", "Error during unsubscribe:", error);
+                        });
+                        break;
+                    case 1002: // Protocol error
+                        this.log("error", "WebSocket protocol error");
+                        break;
+                    case 1006: // Abnormal closure (connection lost)
+                        this.log("warn", "Abnormal WebSocket closure - connection lost");
+                        break;
+                    case 1008: // Policy violation (e.g., unsupported message type)
+                        this.log("error", "WebSocket policy violation - unsupported data");
+                        break;
+                    default:
+                        this.log("warn", `WebSocket closed with code: ${event.code}`);
                 }
-            }
-            catch (error) {
-                if (this.connectionState !== ConnectionState.CLOSING) {
-                    this.log("error", "Fatal status handler error:", error);
+                // Only reconnect if not a normal closure (1000) and reconnect is enabled
+                if (this.shouldReconnect && event.code !== 1000) {
+                    this.scheduleReconnect();
                 }
-            }
-        })();
-    }
-    async createPullSubscription() {
-        if (!this.nc || !this.streamName || !this.consumerName) {
-            throw new Error("Not properly initialized");
-        }
-        this.clearSubscriptions();
-        try {
-            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.subscription = sub;
-            this.pending = 0;
-            // Start message processing loop
-            this.processMessages(sub);
-            this.pull();
-            this.log("info", "Pull subscription created successfully");
+            };
         }
         catch (error) {
-            this.log("error", "Failed to create subscriptions:", error);
+            this.connectionState = ConnectionState.DISCONNECTED;
+            this.log("error", "Failed to connect:", error);
             throw error;
         }
     }
-    async processMessages(sub) {
-        try {
-            for await (const msg of sub) {
-                // Early exit if we're closing or disconnected
-                if (this.connectionState === ConnectionState.CLOSING ||
-                    this.connectionState === ConnectionState.DISCONNECTED) {
-                    this.log("info", "Subscription closing");
-                    break;
-                }
-                try {
-                    await this.handleMessage(msg);
-                }
-                catch (error) {
-                    this.log("error", "Error handling message:", error);
-                }
-            }
+    scheduleReconnect() {
+        if (this.maxReconnectAttempts !== -1 &&
+            this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.log("error", "Max reconnection attempts reached");
+            this.shouldReconnect = false;
+            return;
         }
-        catch (error) {
-            if (this.connectionState !== ConnectionState.CLOSING) {
-                this.log("error", "Message processing error:", error);
+        this.reconnectAttempts++;
+        const delay = Math.min(this.reconnectTimeWait * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectTimeWait);
+        this.log("info", `Scheduling reconnect attempt ${this.reconnectAttempts} in ${delay}ms`);
+        setTimeout(() => {
+            if (this.shouldReconnect &&
+                this.connectionState === ConnectionState.DISCONNECTED) {
+                this.connect().catch((error) => {
+                    this.log("error", "Reconnection failed:", error);
+                });
             }
-        }
+        }, delay);
     }
-    async handleMessage(msg) {
-        console.log("debug", "The complete message", msg);
-        // Check if we have headers with status codes (JetStream control messages)
-        if (msg.headers) {
-            const status = msg.headers.code;
-            const description = msg.headers.description;
-            if (status) {
-                this.log("debug", `Status message: ${status} - ${description}`);
-                await this.handleStatusMessage(status, description, msg);
+    handleMessage(data) {
+        try {
+            const message = fromBinary(WebsocketMessageSchema, new Uint8Array(data));
+            const now = Date.now();
+            // Check if we've already processed this message
+            if (this.ackedMessages.has(message.id)) {
+                this.log("debug", `Skipping already processed message: ${message.id}`);
+                this.sendAck(message.id);
                 return;
             }
-        }
-        // Get the actual stream subject
-        if (!msg.subject) {
-            this.log("warn", `Message without valid subject`);
-            return;
-        }
-        // Now, we need to count the messages that are actually on the consumer's subject
-        // which is what we are pulling
-        this.pending--;
-        if (this.pending <= 0) {
-            this.pull();
-        }
-        // Process the message based on the last part of the subject
-        const parts = msg.subject.split(".");
-        const action = parts[parts.length - 1];
-        this.log("info", `↓ message: ${action} on ${msg.subject}`);
-        // Check if we have data to process
-        if (!msg.data || msg.data.length === 0) {
-            this.log("warn", `Empty message for action ${action}`);
-            this.ack(msg);
-            return;
-        }
-        try {
-            switch (action) {
+            this.sendAck(message.id);
+            // Mark as processed with timestamp
+            this.ackedMessages.set(message.id, now);
+            this.log("debug", `Received message with ID: ${message.id}`);
+            // Process the message based on its type
+            switch (message.message.case) {
                 case "output": {
                     if (this.outputHandler) {
-                        const output = fromBinary(OutputSchema, msg.data);
+                        const output = message.message.value;
                         this.outputHandler({
                             vertex: output.vertex,
                             fork: output.fork,
                             data: parseOutputData(output.data),
-                            created: timestampDate(output.created),
+                            created: output.created
+                                ? timestampDate(output.created)
+                                : undefined,
                         });
                     }
                     break;
                 }
                 case "session": {
+                    const session = message.message.value;
                     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);
+                        const url = message.message.value;
                         this.urlHandler(toJson(UrlSchema, url));
                     }
                     break;
                 }
                 default:
-                    this.log("error", `Unknown message action: ${action}`);
+                    this.log("warn", "Received message with unknown type");
             }
-            this.ack(msg);
         }
         catch (error) {
-            this.log("error", `Error processing ${action} message:`, error);
-            this.nak(msg);
-        }
-    }
-    async handleStatusMessage(status, description, msg) {
-        switch (status) {
-            // This should never be received in a pull consumer without no_wait: true
-            case STATUS_NO_MESSAGES:
-                this.log("warn", `No messages available: ${description}`);
-                this.log("debug", "Headers", msg.headers);
-                break;
-            // This should never be received in a pull consumer without expires: ns
-            case STATUS_REQUEST_TIMEOUT:
-                this.log("warn", `Request timeout: ${description}`);
-                this.log("debug", "Headers", msg.headers);
-                break;
-            case STATUS_MAX_ACK_PENDING:
-                this.log("error", `Max ack pending: ${description}`);
-                this.log("error", "You are throwing excpetion in your handlers or processing messages too slowly. Please ensure you are acknowledging messages properly.");
-                await this.unsubscribe();
-                break;
-            case STATUS_FLOW_CONTROL:
-                this.log("debug", `Flow control: ${description}`);
-                this.ack(msg);
-                break;
-            default:
-                this.log("debug", `Unknown status ${status}: ${description}`);
+            this.log("error", "Error processing message:", error);
+            // Note: We already sent ACK, as per the requirement to ACK immediately
         }
     }
-    async nak(msg) {
-        if (!msg || !this.nc) {
-            throw new Error("Invalid message or connection not established");
-        }
-        if (!msg.reply) {
-            this.log("warn", "Message has no reply subject for NAK");
-            return;
-        }
-        this.log("debug", `Sending NAK for message: '${msg.subject}' on '${msg.reply}'`);
-        this.nc.publish(msg.reply, ACK_NEGATIVE);
-    }
-    ack(msg) {
-        if (!msg || !this.nc) {
-            throw new Error("Invalid message or connection not established");
-        }
-        if (!msg.reply) {
-            this.log("warn", "Message has no reply subject for ACK");
-            return;
-        }
-        this.log("debug", `Sending ACK for message: '${msg.subject}' on '${msg.reply}'`);
-        this.nc.publish(msg.reply, new Uint8Array(0));
-    }
-    pull() {
-        if (!this.nc || !this.inbox) {
-            this.log("error", "NATS connection or inbox not initialized");
-            throw new Error("NATS connection or inbox not initialized");
-        }
-        if (this.connectionState !== ConnectionState.CONNECTED) {
-            this.log("warn", "Not connected, cannot pull messages");
-            return;
-        }
-        if (this.pending > 0) {
-            this.log("warn", `Already have outstanding messages: ${this.pending}`);
+    sendAck(messageId) {
+        this.cleanupOldAckedMessages(Date.now());
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this.log("error", "Cannot send ACK: WebSocket not connected");
             return;
         }
         try {
-            const pullSubject = `${CONSUMER_MSG_NEXT_PREFIX}${this.streamName}.${this.consumerName}`;
-            this.log("debug", `Pulling messages from: ${pullSubject}`);
-            this.nc.publish(pullSubject, this.jc.encode({
-                batch: MESSAGE_BATCH_SIZE,
-                no_wait: false,
-            }), {
-                reply: this.inbox,
-            });
-            this.pending = MESSAGE_BATCH_SIZE;
-            this.log("debug", `Pull sent: batch=${MESSAGE_BATCH_SIZE}, pending=${this.pending}`);
+            // Parse UUID string to bytes (16 bytes)
+            const uuid = new Uint8Array(parseUuid(messageId));
+            // Send the UUID as binary message
+            this.ws.send(uuid);
+            this.log("debug", `Sent ACK for message: ${messageId}`);
         }
         catch (error) {
-            this.log("error", "Error sending pull request:", error);
-            throw error;
+            this.log("error", `Failed to send ACK for ${messageId}:`, error);
         }
     }
-    clearSubscriptions() {
-        if (!this.subscription)
-            return;
-        this.log("debug", "Clearing subscription");
-        try {
-            this.subscription.unsubscribe();
-            this.log("debug", "✓ Subscription cleared");
-        }
-        catch (error) {
-            this.log("error", "Error clearing subscription:", error);
+    cleanupOldAckedMessages(now) {
+        const deadline = now - 60000;
+        for (const [messageId, timestamp] of this.ackedMessages.entries()) {
+            if (timestamp < deadline) {
+                this.ackedMessages.delete(messageId);
+            }
         }
-        this.subscription = null;
-    }
-    async resubscribe() {
-        if (!this.streamName || !this.consumerName)
-            return;
-        this.log("info", "Resubscribing after reconnection");
-        // Recreate subscription
-        await this.createPullSubscription();
-        this.log("info", "✓ Resubscribed successfully");
     }
     cleanupState() {
-        this.streamName = null;
-        this.consumerName = null;
+        this.sessionToken = null;
+        this.automation = null;
         this.outputHandler = null;
         this.sessionHandler = null;
         this.urlHandler = null;
-        this.inbox = null;
-        this.pending = 0;
+        this.ackedMessages.clear();
     }
     async unsubscribe() {
         if (this.connectionState === ConnectionState.DISCONNECTED ||
@@ -496,19 +358,18 @@ export class PubsubClient {
         }
         this.log("info", "Starting unsubscribe process");
         this.connectionState = ConnectionState.CLOSING;
-        this.clearSubscriptions();
+        this.shouldReconnect = false;
         this.cleanupState();
-        this.isReconnecting = false;
-        if (this.nc && !this.nc.isClosed()) {
+        if (this.ws) {
             try {
-                await this.nc.close();
-                this.log("debug", "Connection closed");
+                this.ws.close(1000, "Client disconnecting");
+                this.log("debug", "WebSocket closed");
             }
             catch (error) {
-                this.log("error", "Error closing connection:", error);
+                this.log("error", "Error closing WebSocket:", error);
             }
+            this.ws = null;
         }
-        this.nc = null;
         this.connectionState = ConnectionState.DISCONNECTED;
         this.log("info", "Unsubscribed successfully");
     }
@@ -530,15 +391,4 @@ function parseOutputData(data) {
         }
     }));
 }
-function createAuthenticator(val) {
-    if (typeof val === "string") {
-        return credsAuthenticator(Uint8Array.from(atob(val), (c) => c.charCodeAt(0)));
-    }
-    else if (val instanceof Uint8Array) {
-        return credsAuthenticator(val);
-    }
-    else {
-        throw new Error("Invalid credentials format");
-    }
-}
 //# sourceMappingURL=index.js.map