@hailer/mcp 0.0.1

package/dist/mcp/utils/hailer-api-client.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Hailer API Client
+ * Provides separate socket and REST API methods for flexible endpoint usage
+ */
+import { HailerClient } from '../hailer-clients';
+import { LogContext } from '../../lib/logger';
+import { FileSpec, UploadResult } from './file-upload';
+export interface RestCallConfig {
+    operation: string;
+    endpoint: string;
+    body?: any;
+    method?: string;
+    timeout?: number;
+    context?: LogContext;
+}
+export declare class HailerApiClient {
+    private clients;
+    private logger;
+    constructor(clients: HailerClient);
+    /**
+     * Makes a socket API call - thin wrapper around clients.socket.request
+     */
+    request<T>(method: string, args?: any[]): Promise<T>;
+    /**
+     * Makes a REST API call
+     */
+    callRest<T>(config: RestCallConfig): Promise<T>;
+    /**
+     * Get workflow schema - uses Socket API to get field definitions
+     */
+    getWorkflowSchema(workflowId: string, phaseId: string): Promise<any>;
+    /**
+     * Fetch activity list - uses v3 Socket API with enhanced pagination and filtering
+     */
+    fetchActivityList(workflowId: string, phaseId?: string, limit?: number, options?: {
+        page?: number;
+        search?: string;
+        sortBy?: string;
+        sortOrder?: string;
+        includeStats?: boolean;
+        returnFlat?: boolean;
+        filters?: any;
+    }): Promise<any>;
+    /**
+     * Create activities - uses Socket API
+     */
+    createActivities(workflowId: string, activities: any[], options?: any): Promise<any>;
+    /**
+     * Update activities - uses Socket API
+     */
+    updateActivities(updates: any[], options?: any): Promise<any>;
+    /**
+     * Fetch discussion messages - uses Socket API, load messages from specified discussion
+     * @param discussionId - The discussion ID to fetch messages from
+     * @param limit - Number of messages to fetch (client-side limiting if API doesn't support it)
+     */
+    fetchDiscussionMessages(discussionId: string, limit?: number): Promise<any>;
+    /**
+     * Fetch previous discussion messages - uses Socket API for pagination
+     * @param oldestMessageId - The ID of the oldest message from previous fetch
+     * @param batches - Number of previous batches to fetch (default: 1)
+     */
+    fetchPreviousDiscussionMessages(oldestMessageId: string, batches?: number): Promise<any>;
+    /**
+     * Fetch activity by ID - uses Socket API
+     */
+    fetchActivityById(activityId: string): Promise<any>;
+    /**
+     * Send discussion message - uses Socket API
+     */
+    sendDiscussionMessage(discussionId: string, content: string, fileIds?: string[]): Promise<any>;
+    /**
+     * Join an activity's discussion by following the activity - uses Socket API
+     * This is the recommended way to join activity discussions.
+     * Returns true if now following, false if was already following and toggled off.
+     */
+    joinActivityDiscussion(activityId: string): Promise<boolean>;
+    /**
+     * Leave an activity's discussion by unfollowing the activity - uses Socket API
+     * Returns true if successfully unfollowed, false if was already not following.
+     */
+    leaveActivityDiscussion(activityId: string): Promise<boolean>;
+    /**
+     * Leave a discussion directly - uses Socket API
+     * This works for any discussion type. For activity discussions, prefer leaveActivityDiscussion().
+     */
+    leaveDiscussion(discussionId: string): Promise<void>;
+    /**
+     * Join a discussion directly - uses Socket API
+     * Note: There's no generic join endpoint. For activity discussions, use joinActivityDiscussion().
+     * For other discussion types, you may need to use invite mechanisms.
+     * This method attempts to fetch the discussion to check if user needs to join.
+     */
+    joinDiscussion(discussionId: string): Promise<{
+        success: boolean;
+        message: string;
+        method?: string;
+    }>;
+    /**
+     * Fetch workspace initialization data - uses Socket API
+     */
+    fetchInit(): Promise<any>;
+    /**
+     * Global search across workspace - uses Socket API
+     */
+    globalSearch(query: string, sections?: string[]): Promise<any>;
+    /**
+     * Upload a file from URL or filesystem path
+     */
+    uploadFile(fileSpec: FileSpec): Promise<UploadResult>;
+    /**
+     * Helper method to create MCP tool responses
+     */
+    createMcpResponse(data: any, operation: string, summary?: string): any;
+    /**
+     * Helper method to create MCP error responses
+     */
+    createMcpError(error: unknown, operation: string): any;
+}
+//# sourceMappingURL=hailer-api-client.d.ts.map

package/dist/mcp/utils/hailer-api-client.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * Hailer API Client
+ * Provides separate socket and REST API methods for flexible endpoint usage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HailerApiClient = void 0;
+const logger_1 = require("../../lib/logger");
+const api_errors_1 = require("./api-errors");
+const file_upload_1 = require("./file-upload");
+class HailerApiClient {
+    clients;
+    logger = (0, logger_1.createLogger)({ component: 'HailerApiClient' });
+    constructor(clients) {
+        this.clients = clients;
+    }
+    /**
+     * Makes a socket API call - thin wrapper around clients.socket.request
+     */
+    async request(method, args) {
+        if (!this.clients.socket) {
+            throw new Error(`Socket client not available for method: ${method}`);
+        }
+        this.logger.debug('Socket API call', { method, args });
+        try {
+            const result = await this.clients.socket.request(method, args || []);
+            this.logger.debug('Socket API success', { method });
+            return result;
+        }
+        catch (error) {
+            // Log with detailed context for debugging
+            this.logger.error('Socket API error', error, {
+                method,
+                args: JSON.stringify(args || []),
+                apiBaseUrl: this.clients.socket.host
+            });
+            throw error;
+        }
+    }
+    /**
+     * Makes a REST API call
+     */
+    async callRest(config) {
+        const url = `${this.clients.socket.host}${config.endpoint}`;
+        return await (0, api_errors_1.makeApiCall)(url, {
+            operation: config.operation,
+            endpoint: config.endpoint,
+            method: config.method || 'POST',
+            body: config.body,
+            timeout: config.timeout,
+            context: config.context,
+            headers: {
+                'hlrkey': this.clients.sessionKey,
+            },
+        });
+    }
+    /**
+     * Get workflow schema - uses Socket API to get field definitions
+     */
+    async getWorkflowSchema(workflowId, phaseId) {
+        return await this.request('v3.activity.template.create', [workflowId, phaseId]);
+    }
+    /**
+     * Fetch activity list - uses v3 Socket API with enhanced pagination and filtering
+     */
+    async fetchActivityList(workflowId, phaseId, limit = 50, options) {
+        // V3 API uses processId and phaseId (not process/phase)
+        const workflowFilter = { processId: workflowId };
+        if (phaseId)
+            workflowFilter.phaseId = phaseId;
+        const requestOptions = {
+            filters: options?.filters,
+            limit,
+            search: options?.search || null,
+            page: options?.page ? options.page + 1 : 1, // v3 uses 1-based page numbering
+            sortBy: options?.sortBy || "updated",
+            sortOrder: options?.sortOrder || "desc",
+            includeStats: options?.includeStats !== undefined ? options?.includeStats : true,
+            returnFlat: options?.returnFlat !== undefined ? options?.returnFlat : true,
+        };
+        this.logger.debug('📋 V3 Activity List API Call', {
+            endpoint: 'v3.activity.list',
+            workflowId,
+            phaseId,
+            limit,
+            hasFilters: !!options?.filters,
+            filterCount: options?.filters?.and?.length || 0,
+        });
+        // Use Format B (simple array) - confirmed working
+        return await this.request('v3.activity.list', [workflowFilter, requestOptions]);
+    }
+    /**
+     * Create activities - uses Socket API
+     */
+    async createActivities(workflowId, activities, options) {
+        console.log('🏭 CREATE ACTIVITIES API CALL');
+        console.log('📋 Workflow ID:', workflowId);
+        console.log('📊 Activities Count:', activities.length);
+        console.log('🎯 Activities Array:', JSON.stringify(activities, null, 2));
+        console.log('⚙️  Options:', JSON.stringify(options || {}, null, 2));
+        this.logger.debug('createActivities called with:', {
+            workflowId,
+            activities: JSON.stringify(activities),
+            options: JSON.stringify(options || {})
+        });
+        console.log('🔌 Calling socket API: v3.activity.createMany');
+        try {
+            const result = await this.request('v3.activity.createMany', [workflowId, activities, options || {}]);
+            console.log('✅ CREATE ACTIVITIES SUCCESS');
+            return result;
+        }
+        catch (error) {
+            console.error('❌ CREATE ACTIVITIES FAILED');
+            throw error;
+        }
+    }
+    /**
+     * Update activities - uses Socket API
+     */
+    async updateActivities(updates, options) {
+        const args = options ? [updates, options] : [updates];
+        return await this.request('v3.activity.updateMany', args);
+    }
+    /**
+     * Fetch discussion messages - uses Socket API, load messages from specified discussion
+     * @param discussionId - The discussion ID to fetch messages from
+     * @param limit - Number of messages to fetch (client-side limiting if API doesn't support it)
+     */
+    async fetchDiscussionMessages(discussionId, limit = 50) {
+        const result = await this.request('v3.discussion.message.latest', [discussionId]);
+        // If API returned messages and we need to limit them, slice the array
+        if (result?.messages && Array.isArray(result.messages) && result.messages.length > limit) {
+            return {
+                ...result,
+                messages: result.messages.slice(0, limit),
+                // Add metadata to indicate truncation
+                truncated: true,
+                originalCount: result.messages.length,
+                requestedLimit: limit
+            };
+        }
+        return result;
+    }
+    /**
+     * Fetch previous discussion messages - uses Socket API for pagination
+     * @param oldestMessageId - The ID of the oldest message from previous fetch
+     * @param batches - Number of previous batches to fetch (default: 1)
+     */
+    async fetchPreviousDiscussionMessages(oldestMessageId, batches = 1) {
+        const allMessages = [];
+        let currentMessageId = oldestMessageId;
+        let totalFetched = 0;
+        this.logger.debug('Starting previous message fetch', {
+            oldestMessageId,
+            batches,
+            totalRequests: batches
+        });
+        for (let i = 0; i < batches; i++) {
+            try {
+                this.logger.debug(`Fetching batch ${i + 1}/${batches}`, {
+                    currentMessageId,
+                    batchNumber: i + 1
+                });
+                const result = await this.request('v3.discussion.message.previous', [currentMessageId]);
+                this.logger.debug(`Batch ${i + 1} API response`, {
+                    hasMessages: !!(result?.messages),
+                    messageCount: result?.messages?.length || 0,
+                    resultKeys: Object.keys(result || {})
+                });
+                if (result?.messages && Array.isArray(result.messages) && result.messages.length > 0) {
+                    allMessages.push(...result.messages);
+                    totalFetched += result.messages.length;
+                    // Update currentMessageId to the oldest message from this batch for next iteration
+                    const oldestInBatch = result.messages[result.messages.length - 1];
+                    currentMessageId = oldestInBatch._id;
+                    this.logger.debug(`Batch ${i + 1}/${batches} fetched successfully`, {
+                        messagesInBatch: result.messages.length,
+                        totalSoFar: totalFetched,
+                        nextMessageId: currentMessageId
+                    });
+                }
+                else {
+                    // No more messages available
+                    this.logger.debug(`No more messages available at batch ${i + 1}`, {
+                        totalFetched,
+                        completedBatches: i,
+                        resultStructure: result
+                    });
+                    break;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error fetching batch ${i + 1}`, {
+                    error: error,
+                    currentMessageId,
+                    batchNumber: i + 1
+                });
+                break;
+            }
+        }
+        const finalResult = {
+            messages: allMessages,
+            totalFetched,
+            batchesCompleted: Math.min(batches, Math.ceil(totalFetched / 50)),
+            oldestMessageId: allMessages.length > 0 ? allMessages[allMessages.length - 1]._id : oldestMessageId,
+            hasMore: totalFetched > 0 // Assume there might be more if we got any messages
+        };
+        this.logger.debug('Previous message fetch completed', finalResult);
+        return finalResult;
+    }
+    /**
+     * Fetch activity by ID - uses Socket API
+     */
+    async fetchActivityById(activityId) {
+        return await this.request('activities.load', [activityId]);
+    }
+    /**
+     * Send discussion message - uses Socket API
+     */
+    async sendDiscussionMessage(discussionId, content, fileIds) {
+        const messageData = { msg: content };
+        if (fileIds && fileIds.length > 0) {
+            messageData.files = fileIds;
+        }
+        return await this.request('messenger.send', [messageData, discussionId]);
+    }
+    /**
+     * Join an activity's discussion by following the activity - uses Socket API
+     * This is the recommended way to join activity discussions.
+     * Returns true if now following, false if was already following and toggled off.
+     */
+    async joinActivityDiscussion(activityId) {
+        // activities.follow toggles the state, but we need to check current state first
+        const activity = await this.fetchActivityById(activityId);
+        // If not already following, call activities.follow to join
+        const result = await this.request('activities.follow', [activityId]);
+        return result; // true if now following, false if unfollowed
+    }
+    /**
+     * Leave an activity's discussion by unfollowing the activity - uses Socket API
+     * Returns true if successfully unfollowed, false if was already not following.
+     */
+    async leaveActivityDiscussion(activityId) {
+        // activities.follow toggles the state
+        const activity = await this.fetchActivityById(activityId);
+        // If already following, call activities.follow to unfollow
+        const result = await this.request('activities.follow', [activityId]);
+        return !result; // Inverse: true if now unfollowed, false if followed
+    }
+    /**
+     * Leave a discussion directly - uses Socket API
+     * This works for any discussion type. For activity discussions, prefer leaveActivityDiscussion().
+     */
+    async leaveDiscussion(discussionId) {
+        return await this.request('messenger.leave_discussion', [discussionId]);
+    }
+    /**
+     * Join a discussion directly - uses Socket API
+     * Note: There's no generic join endpoint. For activity discussions, use joinActivityDiscussion().
+     * For other discussion types, you may need to use invite mechanisms.
+     * This method attempts to fetch the discussion to check if user needs to join.
+     */
+    async joinDiscussion(discussionId) {
+        // Try to fetch messages to check if already a member
+        try {
+            await this.request('v3.discussion.message.latest', [discussionId]);
+            return {
+                success: true,
+                message: 'Already a member of this discussion or successfully accessed it',
+                method: 'direct_access'
+            };
+        }
+        catch (error) {
+            // Check if error indicates permission/access issue
+            const errorMsg = error?.message || String(error);
+            if (errorMsg.toLowerCase().includes('permission') ||
+                errorMsg.toLowerCase().includes('access') ||
+                errorMsg.toLowerCase().includes('not found')) {
+                // This is likely an activity discussion - we need the activity ID
+                throw new Error('Cannot join this discussion directly. If this is an activity discussion, ' +
+                    'please use join_activity_discussion tool with the activity ID instead. ' +
+                    'For other discussion types, you may need an invitation.');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Fetch workspace initialization data - uses Socket API
+     */
+    async fetchInit() {
+        return await this.request('v2.core.init', [{}]);
+    }
+    /**
+     * Global search across workspace - uses Socket API
+     */
+    async globalSearch(query, sections) {
+        const searchOptions = { search: query };
+        if (sections) {
+            searchOptions.sections = sections;
+        }
+        return await this.request('v2.search.global', [searchOptions]);
+    }
+    /**
+     * Upload a file from URL or filesystem path
+     */
+    async uploadFile(fileSpec) {
+        return await (0, file_upload_1.uploadSingleFile)(fileSpec, this.clients);
+    }
+    /**
+     * Helper method to create MCP tool responses
+     */
+    createMcpResponse(data, operation, summary) {
+        return (0, api_errors_1.createSuccessResponse)(data, operation, summary);
+    }
+    /**
+     * Helper method to create MCP error responses
+     */
+    createMcpError(error, operation) {
+        return (0, api_errors_1.createErrorResponse)(error, operation);
+    }
+}
+exports.HailerApiClient = HailerApiClient;
+//# sourceMappingURL=hailer-api-client.js.map

package/dist/mcp/utils/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Utility exports for Hailer MCP Server
+ * Provides centralized access to all utility functions and types
+ */
+export { createLogger, getDefaultLogger as logger, LogLevel, LogTag } from '../../lib/logger';
+export type { LogContext } from '../../lib/logger';
+export { HailerApiError, makeApiCall, handleApiResponse, createErrorResponse, createSuccessResponse } from './api-errors';
+export type { ApiCallOptions } from './api-errors';
+export { HailerApiClient } from './hailer-api-client';
+export type { RestCallConfig } from './hailer-api-client';
+export { transformActivity, transformActivities, transformFields, transformFieldValue, findFieldByKey, transformWorkflow, transformPhases, transformWorkflowFields, formatTimestamp, formatUserName, getFirstPhaseId, formatActivityListResponse, transformActivityForSearch, } from './data-transformers';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/utils/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Utility exports for Hailer MCP Server
+ * Provides centralized access to all utility functions and types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformActivityForSearch = exports.formatActivityListResponse = exports.getFirstPhaseId = exports.formatUserName = exports.formatTimestamp = exports.transformWorkflowFields = exports.transformPhases = exports.transformWorkflow = exports.findFieldByKey = exports.transformFieldValue = exports.transformFields = exports.transformActivities = exports.transformActivity = exports.HailerApiClient = exports.createSuccessResponse = exports.createErrorResponse = exports.handleApiResponse = exports.makeApiCall = exports.HailerApiError = exports.LogTag = exports.LogLevel = exports.logger = exports.createLogger = void 0;
+// Logging utilities
+var logger_1 = require("../../lib/logger");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_1.createLogger; } });
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.getDefaultLogger; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
+Object.defineProperty(exports, "LogTag", { enumerable: true, get: function () { return logger_1.LogTag; } });
+// Error handling utilities
+var api_errors_1 = require("./api-errors");
+Object.defineProperty(exports, "HailerApiError", { enumerable: true, get: function () { return api_errors_1.HailerApiError; } });
+Object.defineProperty(exports, "makeApiCall", { enumerable: true, get: function () { return api_errors_1.makeApiCall; } });
+Object.defineProperty(exports, "handleApiResponse", { enumerable: true, get: function () { return api_errors_1.handleApiResponse; } });
+Object.defineProperty(exports, "createErrorResponse", { enumerable: true, get: function () { return api_errors_1.createErrorResponse; } });
+Object.defineProperty(exports, "createSuccessResponse", { enumerable: true, get: function () { return api_errors_1.createSuccessResponse; } });
+// API client
+var hailer_api_client_1 = require("./hailer-api-client");
+Object.defineProperty(exports, "HailerApiClient", { enumerable: true, get: function () { return hailer_api_client_1.HailerApiClient; } });
+// Data transformers
+var data_transformers_1 = require("./data-transformers");
+Object.defineProperty(exports, "transformActivity", { enumerable: true, get: function () { return data_transformers_1.transformActivity; } });
+Object.defineProperty(exports, "transformActivities", { enumerable: true, get: function () { return data_transformers_1.transformActivities; } });
+Object.defineProperty(exports, "transformFields", { enumerable: true, get: function () { return data_transformers_1.transformFields; } });
+Object.defineProperty(exports, "transformFieldValue", { enumerable: true, get: function () { return data_transformers_1.transformFieldValue; } });
+Object.defineProperty(exports, "findFieldByKey", { enumerable: true, get: function () { return data_transformers_1.findFieldByKey; } });
+Object.defineProperty(exports, "transformWorkflow", { enumerable: true, get: function () { return data_transformers_1.transformWorkflow; } });
+Object.defineProperty(exports, "transformPhases", { enumerable: true, get: function () { return data_transformers_1.transformPhases; } });
+Object.defineProperty(exports, "transformWorkflowFields", { enumerable: true, get: function () { return data_transformers_1.transformWorkflowFields; } });
+Object.defineProperty(exports, "formatTimestamp", { enumerable: true, get: function () { return data_transformers_1.formatTimestamp; } });
+Object.defineProperty(exports, "formatUserName", { enumerable: true, get: function () { return data_transformers_1.formatUserName; } });
+Object.defineProperty(exports, "getFirstPhaseId", { enumerable: true, get: function () { return data_transformers_1.getFirstPhaseId; } });
+Object.defineProperty(exports, "formatActivityListResponse", { enumerable: true, get: function () { return data_transformers_1.formatActivityListResponse; } });
+Object.defineProperty(exports, "transformActivityForSearch", { enumerable: true, get: function () { return data_transformers_1.transformActivityForSearch; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/utils/logger.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Structured logging utility for Hailer MCP Server
+ * Provides consistent logging across the application with configurable levels
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export interface LogContext {
+    operation?: string;
+    endpoint?: string;
+    activityId?: string;
+    workflowId?: string;
+    discussionId?: string;
+    userId?: string;
+    duration?: number;
+    [key: string]: any;
+}
+declare class Logger {
+    private level;
+    private context;
+    setLevel(level: LogLevel): void;
+    setContext(context: LogContext): Logger;
+    private withContext;
+    private shouldLog;
+    private formatMessage;
+    private getEmoji;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, error?: Error | unknown, context?: LogContext): void;
+    apiCall(operation: string, endpoint: string, params?: any): void;
+    apiSuccess(operation: string, endpoint: string, duration?: number): void;
+    apiError(operation: string, endpoint: string, error: Error | unknown, duration?: number): void;
+    socketFallback(operation: string, reason: string): void;
+}
+export declare const logger: Logger;
+export declare function createLogger(context: LogContext): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/mcp/utils/logger.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Structured logging utility for Hailer MCP Server
+ * Provides consistent logging across the application with configurable levels
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    level = LogLevel.DEBUG;
+    context = {};
+    setLevel(level) {
+        this.level = level;
+    }
+    setContext(context) {
+        return new Logger().withContext({ ...this.context, ...context });
+    }
+    withContext(context) {
+        const newLogger = new Logger();
+        newLogger.level = this.level;
+        newLogger.context = context;
+        return newLogger;
+    }
+    shouldLog(level) {
+        return level >= this.level;
+    }
+    formatMessage(level, message, context) {
+        const emoji = this.getEmoji(level);
+        const levelName = LogLevel[level];
+        const fullContext = { ...this.context, ...context };
+        let contextStr = '';
+        if (Object.keys(fullContext).length > 0) {
+            const contextParts = Object.entries(fullContext)
+                .filter(([_, value]) => value !== undefined && value !== null)
+                .map(([key, value]) => `${key}=${value}`);
+            if (contextParts.length > 0) {
+                contextStr = ` [${contextParts.join(', ')}]`;
+            }
+        }
+        return `${emoji} ${levelName}: ${message}${contextStr}`;
+    }
+    getEmoji(level) {
+        switch (level) {
+            case LogLevel.DEBUG: return '🔍';
+            case LogLevel.INFO: return '📡';
+            case LogLevel.WARN: return '⚠️';
+            case LogLevel.ERROR: return '❌';
+            default: return '📝';
+        }
+    }
+    debug(message, context) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            console.log(this.formatMessage(LogLevel.DEBUG, message, context));
+        }
+    }
+    info(message, context) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            console.log(this.formatMessage(LogLevel.INFO, message, context));
+        }
+    }
+    warn(message, context) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            console.warn(this.formatMessage(LogLevel.WARN, message, context));
+        }
+    }
+    error(message, error, context) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const fullMessage = error ? `${message}: ${errorMsg}` : message;
+            console.error(this.formatMessage(LogLevel.ERROR, fullMessage, context));
+            if (error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+    // Convenience methods for common operations
+    apiCall(operation, endpoint, params) {
+        this.debug(`API call: ${operation}`, { operation, endpoint, params: params ? JSON.stringify(params) : undefined });
+    }
+    apiSuccess(operation, endpoint, duration) {
+        this.info(`API success: ${operation}`, { operation, endpoint, duration });
+    }
+    apiError(operation, endpoint, error, duration) {
+        this.error(`API error: ${operation}`, error, { operation, endpoint, duration });
+    }
+    socketFallback(operation, reason) {
+        this.warn(`Socket fallback: ${operation} - ${reason}`, { operation });
+    }
+}
+// Export singleton instance
+exports.logger = new Logger();
+// Export factory function for creating loggers with specific context
+function createLogger(context) {
+    return exports.logger.setContext(context);
+}
+//# sourceMappingURL=logger.js.map