@hailer/mcp 0.0.1

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

@@ -0,0 +1,286 @@
+/**
+ * Shared type definitions for Hailer MCP Server
+ * Consolidates interfaces used across multiple files
+ */
+export type { CleanActivity, FieldValue, WorkflowInfo, PhaseInfo, FieldInfo, UserInfo, } from './data-transformers';
+export interface HailerField {
+    data: any[];
+    label: string;
+    required: boolean;
+    type: string;
+    inviteToDiscussionOnChange: boolean;
+    _id: string;
+    functionEnabled: boolean;
+    unit?: string;
+    created?: number;
+    updated?: number;
+    uid?: string;
+    description?: string;
+    defaultTo?: boolean;
+}
+export interface HailerPhase {
+    _id: string;
+    name: string;
+    description: string;
+    fields: string[];
+    announcementFields: any[];
+    announcementRecipients: any[];
+    announcementFieldsOrder: any[];
+    isEndpoint: boolean;
+    possibleNextPhase: string[];
+    possibleNextPhaseSettings: object;
+    created: number;
+    members: any[];
+    followers: any[];
+}
+export interface HailerTranslationField {
+    label: string;
+    unit?: string;
+    description?: string;
+}
+export interface HailerTranslationPhase {
+    name: string;
+    description: string;
+    possibleNextPhaseSettings: object;
+}
+export interface HailerTranslation {
+    name: string;
+    phases: Record<string, HailerTranslationPhase>;
+    nameColumnText: string;
+    nameFieldPlaceHolderText: string;
+    fields: Record<string, HailerTranslationField>;
+    description?: string;
+    createNewLabel?: string;
+    personInChargeLabel?: string;
+}
+export interface HailerMember {
+    id: string;
+    info: object;
+    permissions: string[];
+}
+export interface HailerProcess {
+    _id: string;
+    name: string;
+    defaultView: string;
+    team?: string;
+    fields: Record<string, HailerField>;
+    fieldsOrder: string[];
+    phasesRemoved: string[];
+    enableAddedField: boolean;
+    enableLinkedAnnouncements: boolean;
+    enableMapLocation: boolean;
+    enableUnlinkedMode: boolean;
+    enableMessenger: boolean;
+    enableModifiedField: boolean;
+    allowGuests: boolean;
+    enableGuestEditing: boolean;
+    enableUniqueName: boolean;
+    enablePreselectedTeam: boolean;
+    enableAttachments: boolean;
+    nameFieldPlaceHolderText: string;
+    phases: Record<string, HailerPhase>;
+    phasesOrder: string[];
+    enablePredefinedName: boolean;
+    nameColumnText: string;
+    order: number;
+    createdActivities: number;
+    createNewLabel: string;
+    personInChargeLabel: string;
+    coverImage: string;
+    translations: Record<string, HailerTranslation>;
+    nameEditable: boolean;
+    cid: string;
+    uid: string;
+    created: number;
+    updated: number;
+    discussionPermissions: string[];
+    members: HailerMember[];
+    description: string;
+    allowCustomTags: boolean;
+    allowMultipleTags: boolean;
+    isStarred: boolean;
+}
+export interface HailerUserLocation {
+    time?: number;
+    lng: number;
+    lat: number;
+    name: string;
+}
+export interface HailerUser {
+    _id: string;
+    firstname: string;
+    lastname: string;
+    default_profilepic: string;
+    companies: string[];
+    status?: string;
+    lastSeen: number;
+    lastLocation?: HailerUserLocation;
+}
+export interface HailerV2CoreInitResponse {
+    processes: HailerProcess[];
+    users: Record<string, HailerUser>;
+    [key: string]: any;
+}
+export interface McpTextContent {
+    type: "text";
+    text: string;
+}
+export interface McpResponse {
+    content: McpTextContent[];
+}
+export interface ActivityListFilters {
+    processId?: string;
+    phaseId?: string;
+    _id?: string;
+    name?: string;
+    uid?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface ActivityCreateData {
+    name: string;
+    fields?: Record<string, any>;
+    description?: string;
+    phaseId?: string;
+    teamId?: string;
+    assigneeEmail?: string;
+    dueDate?: string;
+}
+export interface ActivityUpdateData {
+    _id: string;
+    name?: string;
+    fields?: Record<string, any>;
+    phaseId?: string;
+}
+export interface DiscussionMessageData {
+    msg: string;
+    discussionId?: string;
+}
+export interface SearchOptions {
+    search: string;
+    sections?: string[];
+    limit?: number;
+    workspaceId?: string;
+}
+export interface InitData {
+    processes: any[];
+    users: Record<string, HailerUser>;
+    currentUser?: HailerUser;
+    workspace?: WorkspaceInfo;
+    networks?: any[];
+}
+export interface WorkspaceInfo {
+    _id: string;
+    name: string;
+    description?: string;
+    members?: string[];
+    settings?: Record<string, any>;
+}
+export interface NetworkInfo {
+    _id: string;
+    name: string;
+    workspaces: string[];
+}
+export interface ClientConfig {
+    email: string;
+    password: string;
+    mcpServerApiKey: string;
+    apiBaseUrl?: string;
+}
+export interface McpConfig {
+    clients: ClientConfig[];
+    logging?: {
+        level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+        enableApiLogging: boolean;
+    };
+}
+export interface ApiErrorInfo {
+    status: number;
+    statusText: string;
+    message: string;
+    operation: string;
+    endpoint: string;
+    responseBody?: string;
+}
+export interface SignalData {
+    type: string;
+    data: any;
+    timestamp: number;
+    workspaceId: string;
+}
+export type SignalType = 'activities.updated' | 'activities.created' | 'activities.deleted' | 'discussion.message' | 'user.joined' | 'user.left' | 'workspace.updated' | 'process.updated';
+export interface SignalSubscription {
+    types: SignalType[];
+    workspaceId?: string;
+    callback: (signal: SignalData) => void;
+}
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Required<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export interface PaginationParams {
+    limit?: number;
+    offset?: number;
+}
+export interface WorkspaceParams {
+    workspaceId?: string;
+}
+export interface TimestampParams {
+    createdAfter?: string;
+    createdBefore?: string;
+    updatedAfter?: string;
+    updatedBefore?: string;
+}
+export interface ListActivitiesParams extends WorkspaceParams, PaginationParams {
+    workflowId: string;
+    phaseId?: string;
+    phaseName?: string;
+    fields?: string[];
+    page?: number;
+    includeStats?: boolean;
+    search?: string;
+    sortBy?: 'name' | 'created' | 'updated' | 'priority';
+    sortOrder?: 'asc' | 'desc';
+    filters?: {
+        [fieldId: string]: {
+            operator: 'text_search' | 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'greater_than_or_equal' | 'less_than' | 'less_than_or_equal' | 'range';
+            value?: string | number;
+            start?: number;
+            end?: number;
+        };
+    };
+}
+export interface FindActivityParams extends WorkspaceParams, PaginationParams {
+    name: string;
+    workflowId?: string;
+    includeWorkflowInfo?: boolean;
+}
+export interface UpdateActivityParams extends WorkspaceParams {
+    activityId: string;
+    name?: string;
+    fields?: Record<string, any> | string;
+    phaseId?: string;
+}
+export interface CreateActivityParams extends WorkspaceParams {
+    workflowId: string;
+    name: string;
+    description?: string;
+    phaseId?: string;
+    teamId?: string;
+    discussionId?: string;
+    fields?: Record<string, any>;
+}
+export interface DiscussionMessageParams {
+    discussionId: string;
+    content: string;
+}
+export interface FetchDiscussionParams {
+    discussionId: string;
+    limit?: number;
+}
+export interface SearchParams extends WorkspaceParams {
+    query: string;
+    sections?: string[];
+    maxResults?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/utils/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Shared type definitions for Hailer MCP Server
+ * Consolidates interfaces used across multiple files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/mcp/workspace-cache.d.ts

@@ -0,0 +1,42 @@
+import { HailerV2CoreInitResponse } from "./utils/index";
+import { McpConfig } from "../config";
+export interface UserInfo {
+    id: string;
+    firstname: string;
+    lastname: string;
+    fullName: string;
+    companies: string[];
+    default_profilepic: string;
+    lastSeen: number;
+}
+export interface WorkspaceCache {
+    users: UserInfo[];
+    usersById: Record<string, UserInfo>;
+    currentWorkspace: any;
+    allWorkspaces: Record<string, any>;
+    workspaceNames: Record<string, string>;
+    timestamp: {
+        users: number;
+        processes: number;
+        networks?: number;
+    };
+    config: McpConfig;
+    rawInit: HailerV2CoreInitResponse;
+}
+/**
+ * Processes init data and creates a structured cache of workspace information
+ */
+export declare function createWorkspaceCache(init: HailerV2CoreInitResponse, config: McpConfig): WorkspaceCache;
+/**
+ * Gets user information by ID
+ */
+export declare function getUserById(cache: WorkspaceCache, userId: string): UserInfo | undefined;
+/**
+ * Gets workspace by name (case-insensitive)
+ */
+export declare function getWorkspaceByName(cache: WorkspaceCache, name: string): any;
+/**
+ * Resolves workspace identifier (ID or name) to workspace ID
+ */
+export declare function resolveWorkspaceId(cache: WorkspaceCache, identifier: string): string | undefined;
+//# sourceMappingURL=workspace-cache.d.ts.map

package/dist/mcp/workspace-cache.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceCache = createWorkspaceCache;
+exports.getUserById = getUserById;
+exports.getWorkspaceByName = getWorkspaceByName;
+exports.resolveWorkspaceId = resolveWorkspaceId;
+/**
+ * Removes empty/default fields from an object to save context space
+ */
+function compactObject(obj, config) {
+    if (!config.excludeEmptyFields || !obj || typeof obj !== 'object') {
+        return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip empty arrays, empty objects, null, undefined, empty strings
+        if (value === null || value === undefined || value === '')
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        if (typeof value === 'object' && Object.keys(value).length === 0)
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Processes init data and creates a structured cache of workspace information
+ */
+function createWorkspaceCache(init, config) {
+    // Process users (global workspace users)
+    const users = [];
+    const usersById = {};
+    Object.values(init.users || {}).forEach((user) => {
+        let userInfo = {
+            id: user._id,
+            firstname: user.firstname,
+            lastname: user.lastname,
+            fullName: `${user.firstname} ${user.lastname}`,
+            companies: user.companies || [],
+            default_profilepic: config.compactUserData ? undefined : user.default_profilepic,
+            lastSeen: config.compactUserData ? 0 : (user.lastSeen || 0),
+        };
+        // Apply compacting if enabled  
+        if (config.excludeEmptyFields) {
+            userInfo = compactObject(userInfo, config);
+        }
+        users.push(userInfo);
+        usersById[user._id] = userInfo;
+    });
+    // Process workspace data
+    const currentWorkspace = init.network || {};
+    const allWorkspaces = init.networks || {};
+    const workspaceNames = {};
+    // Build workspace name mapping
+    Object.values(allWorkspaces).forEach((workspace) => {
+        if (workspace._id && workspace.name) {
+            workspaceNames[workspace._id] = workspace.name;
+        }
+    });
+    return {
+        users,
+        usersById,
+        currentWorkspace,
+        allWorkspaces,
+        workspaceNames,
+        timestamp: init.timestamp || { users: 0, processes: 0 },
+        config,
+        rawInit: init,
+    };
+}
+/**
+ * Gets user information by ID
+ */
+function getUserById(cache, userId) {
+    return cache.usersById[userId];
+}
+/**
+ * Gets workspace by name (case-insensitive)
+ */
+function getWorkspaceByName(cache, name) {
+    const lowerName = name.toLowerCase();
+    return Object.values(cache.allWorkspaces).find((ws) => ws.name && ws.name.toLowerCase() === lowerName);
+}
+/**
+ * Resolves workspace identifier (ID or name) to workspace ID
+ */
+function resolveWorkspaceId(cache, identifier) {
+    // Direct ID match
+    if (cache.allWorkspaces[identifier]) {
+        return identifier;
+    }
+    // Name-based lookup
+    const workspace = getWorkspaceByName(cache, identifier);
+    return workspace?._id;
+}
+//# sourceMappingURL=workspace-cache.js.map

package/dist/mcp-server.d.ts

@@ -0,0 +1,42 @@
+/**
+ * MCPServerService - Handles Express app, routes, and HTTP server management
+ *
+ * Implements JSON-RPC 2.0 MCP protocol over HTTP with Server-Sent Events (SSE)
+ * for LLM clients (Claude Desktop, etc.)
+ */
+import { Express } from 'express';
+import { Logger } from './lib/logger';
+import { ToolRegistry } from './mcp/tool-registry';
+declare module 'express-serve-static-core' {
+    interface Request {
+        logger: Logger;
+    }
+}
+export interface MCPServerConfig {
+    port: number;
+    corsOrigins: string[];
+    toolRegistry: ToolRegistry;
+}
+export declare class MCPServerService {
+    private app;
+    private server?;
+    private logger;
+    private config;
+    private toolRegistry;
+    constructor(config: MCPServerConfig);
+    private setupMiddleware;
+    private setupRoutes;
+    /**
+     * Check if agent has access to a specific tool
+     */
+    private canAccessTool;
+    /**
+     * Send MCP error response
+     */
+    private sendMcpError;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getApp(): Express;
+    isRunning(): boolean;
+}
+//# sourceMappingURL=mcp-server.d.ts.map