@minded-ai/mindedjs 2.0.5 → 2.0.6-beta-2

package/src/platform/mindedConnection.ts

@@ -6,6 +6,12 @@ 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: {
@@ -76,16 +82,21 @@ const getSdkVersion = (): string => {
   try {
     return packageJson.version;
   } catch {
-    logger.warn('Could not determine SDK version');
+    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 = isDeployed ? 3 : 0;
+  const maxRetries = 3;
 
-  logger.info(`Connecting to Minded platform: ${baseUrl}${retryCount > 0 ? ` (retry ${retryCount}/${maxRetries})` : ''}`);
+  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, {
@@ -101,33 +112,40 @@ const connect = async (token: string, retryCount: number = 0): Promise<void> =>
 
     let connected = false;
     let ready = false;
+    let isRetrying = false; // Flag to prevent multiple concurrent retries
 
     const checkReady = () => {
       if (connected && ready) {
-        logger.info({ msg: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
-        logger.info({ msg: '\x1b[32mPress Ctrl+C to exit...' });
+        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: 'Socket connected, waiting for server setup...' });
+      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: 'Server ready signal received', data });
+      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 (isDeployed && retryCount < maxRetries) {
-        logger.info({ msg: `Retrying connection in ${(retryCount + 1) * 2} seconds...` });
+      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) {
@@ -147,23 +165,23 @@ const connect = async (token: string, retryCount: number = 0): Promise<void> =>
         }
       } else {
         // No more retries or not in cloud mode
-        logger.error({ msg: 'Failed to connect to minded platform', err });
-        reject(new Error('Failed to connect to minded platform'));
+        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: 'Disconnected from local debugging socket' });
+      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: 'Server error:', error });
+      logger.error({ msg: colorize('[Agent] Server error:', '\x1b[31m'), error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info({ msg: 'Invalid token' });
+        logger.info({ msg: colorize('[Agent] Invalid token', '\x1b[33m') });
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -185,14 +203,14 @@ const connect = async (token: string, retryCount: number = 0): Promise<void> =>
           }
         });
       } else {
-        console.warn({ msg: 'No listeners found for event', event });
+        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: '\nDisconnecting...' });
+        logger.info({ msg: colorize('[Agent] Disconnecting...', '\x1b[33m') });
         socket.disconnect();
       }
       process.exit(0);
@@ -203,24 +221,24 @@ const connect = async (token: string, retryCount: number = 0): Promise<void> =>
 export const start = async (): Promise<void> => {
   const { token } = getConfig();
   if (!token) {
-    throw new Error('Minded token not found');
+    throw new Error('[Agent] Minded token not found');
   }
   await connect(token);
 };
 
 export const disconnect = () => {
   if (!socket) {
-    logger.warn({ msg: 'No socket connection to disconnect' });
+    logger.warn({ msg: colorize('[Agent] No socket connection to disconnect', '\x1b[33m') });
     return;
   }
 
   if (socket.connected) {
-    logger.info({ msg: 'Disconnecting from Minded platform...' });
+    logger.info({ msg: colorize('[Agent] Disconnecting from Minded platform...', '\x1b[33m') });
     socket.disconnect();
     return;
   }
 
-  logger.warn({ msg: 'Socket is already disconnected' });
+  logger.warn({ msg: colorize('[Agent] Socket is already disconnected', '\x1b[33m') });
 };
 
 export const mindedConnection = {

package/src/utils/logger.ts

@@ -29,6 +29,7 @@ export const logger = pino(
         return { level: label };
       },
     },
+    timestamp: () => `,"time":"${new Date().toISOString()}"`,
     serializers: {
       err: pino.stdSerializers.err,
     },