@minded-ai/mindedjs 1.0.0-ec2-beta-1

package/src/platform/mindedConnection.ts

@@ -0,0 +1,250 @@
+import { io, Socket } from 'socket.io-client';
+import { mindedConnectionSocketMessageType, mindedConnectionSocketMessageTypeMap } from './mindedConnectionTypes';
+import { stringify } from 'flatted';
+import { getConfig } from './config';
+import { logger } from '../utils/logger';
+import { wait } from '../utils/wait';
+import * as packageJson from '../../package.json';
+
+// Helper function to conditionally add colors to messages
+const colorize = (message: string, colorCode: string): string => {
+  const isCloud = process.env.MINDED_CLOUD === 'true';
+  return isCloud ? message : `${colorCode}${message}\x1b[0m`;
+};
+
+// Module-level singleton state
+let socket: Socket | null = null;
+const listeners: {
+  [key: string]: ((message: any) => any)[];
+} = {};
+
+export const isConnected = (): boolean => {
+  return socket?.connected ?? false;
+};
+
+export const on = <E extends keyof mindedConnectionSocketMessageTypeMap>(
+  event: E,
+  callback: (message: mindedConnectionSocketMessageTypeMap[E]) => any,
+) => {
+  if (!listeners[event]) {
+    listeners[event] = [];
+  }
+  listeners[event].push(callback);
+};
+
+export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(event: E, message: mindedConnectionSocketMessageTypeMap[E]) => {
+  if (socket) {
+    socket.emit(event, message);
+  }
+};
+
+export const awaitEmit = async <T, R>(event: mindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
+  if (!socket) {
+    throw new Error('Socket is not connected');
+  }
+
+  await waitForConnection();
+
+  return new Promise((resolve, reject) => {
+    // Set up timeout
+    const timeout = setTimeout(() => {
+      reject(new Error(`Acknowledgement timeout after ${timeoutMs}ms; event type: ${event}}`));
+    }, timeoutMs);
+
+    // Emit with acknowledgement callback
+    socket!.emit(event, stringify(message), (response: any) => {
+      clearTimeout(timeout);
+
+      // Check if the response indicates an error
+      if (response && response.error) {
+        reject(new Error(response.error));
+      } else {
+        resolve(response);
+      }
+    });
+  });
+};
+
+const waitForConnection = async (): Promise<void> => {
+  const timeout = 10000;
+  const interval = 100;
+  let cnt = 0;
+  while (!isConnected()) {
+    await wait(interval);
+    cnt += interval;
+    if (cnt > timeout) {
+      throw new Error('Minded connection timeout');
+    }
+  }
+};
+
+const getSdkVersion = (): string => {
+  try {
+    return packageJson.version;
+  } catch {
+    logger.warn({ msg: colorize('[Agent] Could not determine SDK version', '\x1b[33m') });
+    return 'unknown';
+  }
+};
+
+const connect = async (token: string, retryCount: number = 0): Promise<void> => {
+  const { isDeployed, baseUrl, env } = getConfig();
+  const maxRetries = 3;
+
+  logger.info({
+    msg: colorize(
+      `[Agent] Connecting to Minded platform: ${baseUrl}${retryCount > 0 ? ` (retry ${retryCount}/${maxRetries})` : ''}`,
+      '\x1b[36m',
+    ),
+  });
+
+  return new Promise<void>((resolve, reject) => {
+    socket = io(baseUrl, {
+      path: '/minded-connect',
+      transports: ['websocket'],
+      query: {
+        isDeployedAgent: isDeployed,
+        token,
+        environment: env,
+        sdkVersion: getSdkVersion(),
+      },
+    });
+
+    let connected = false;
+    let ready = false;
+    let isRetrying = false; // Flag to prevent multiple concurrent retries
+
+    const checkReady = () => {
+      if (connected && ready) {
+        logger.info({ msg: colorize('[Agent] Connection with Minded platform is ready!', '\x1b[32m') });
+        logger.info({ msg: colorize('[Agent] Press Ctrl+C to exit...', '\x1b[32m') });
+        resolve();
+      }
+    };
+
+    // Connection event handlers
+    socket.on('connect', () => {
+      logger.info({ msg: colorize('[Agent] Socket connected, waiting for server setup...', '\x1b[36m') });
+      connected = true;
+      checkReady();
+    });
+
+    // Listen for ready event from server
+    socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
+      logger.info({ msg: colorize('[Agent] Server ready signal received', '\x1b[32m'), data });
+      ready = true;
+      checkReady();
+    });
+
+    socket.on('connect_error', async (err) => {
+      // Prevent multiple concurrent retry attempts
+      if (isRetrying) {
+        return;
+      }
+
+      // If we're in cloud mode and haven't exhausted retries, try again
+      if (retryCount < maxRetries) {
+        isRetrying = true;
+        logger.info({ msg: colorize(`[Agent] Retrying connection in ${(retryCount + 1) * 2} seconds...`, '\x1b[33m') });
+
+        // Disconnect current socket
+        if (socket?.connected) {
+          socket.disconnect();
+        }
+        socket = null;
+
+        // Wait with exponential backoff
+        await wait((retryCount + 1) * 2000);
+
+        // Retry connection
+        try {
+          await connect(token, retryCount + 1);
+          resolve();
+        } catch (retryErr) {
+          reject(retryErr);
+        }
+      } else {
+        // No more retries or not in cloud mode
+        logger.error({ msg: colorize('[Agent] Failed to connect to minded platform', '\x1b[31m'), err });
+        reject(new Error('[Agent] Failed to connect to minded platform'));
+      }
+    });
+
+    socket.on('disconnect', () => {
+      logger.info({ msg: colorize('[Agent] Disconnected from local debugging socket', '\x1b[33m') });
+      connected = false;
+      ready = false;
+    });
+
+    // Listen for error messages from the server
+    socket.on('error', async (error: { message: string }) => {
+      logger.error({ msg: colorize('[Agent] Server error:', '\x1b[31m'), error });
+
+      if (error.message.includes('Invalid token')) {
+        logger.info({ msg: colorize('[Agent] Invalid token', '\x1b[33m') });
+
+        // Disconnect current socket
+        if (socket?.connected) {
+          socket.disconnect();
+        }
+
+        // Get new token and reconnect (start fresh with retry count 0)
+        await connect(token, 0);
+      }
+    });
+
+    // Listen for specific message types
+    socket.onAny((event, message, callback) => {
+      if (listeners[event]) {
+        listeners[event].forEach(async (listener) => {
+          const res = await listener(message);
+          if (callback) {
+            callback(res);
+          }
+        });
+      } else {
+        logger.warn({ msg: colorize('[Agent] No listeners found for event', '\x1b[33m'), event });
+      }
+    });
+
+    // Handle process termination
+    process.on('SIGINT', () => {
+      if (socket?.connected) {
+        logger.info({ msg: colorize('[Agent] Disconnecting...', '\x1b[33m') });
+        socket.disconnect();
+      }
+      process.exit(0);
+    });
+  });
+};
+
+export const start = async (): Promise<void> => {
+  const { token } = getConfig();
+  if (!token) {
+    throw new Error('[Agent] Minded token not found');
+  }
+  await connect(token);
+};
+
+export const disconnect = () => {
+  if (!socket) {
+    logger.warn({ msg: colorize('[Agent] No socket connection to disconnect', '\x1b[33m') });
+    return;
+  }
+
+  if (socket.connected) {
+    logger.info({ msg: colorize('[Agent] Disconnecting from Minded platform...', '\x1b[33m') });
+    socket.disconnect();
+    return;
+  }
+
+  logger.warn({ msg: colorize('[Agent] Socket is already disconnected', '\x1b[33m') });
+};
+
+export const mindedConnection = {
+  isConnected,
+  on,
+  emit,
+  awaitEmit,
+  start,
+};