@hexabot-ai/api 3.0.0-alpha.3 → 3.1.0-alpha.0

package/src/websocket/websocket.gateway.ts

@@ -4,6 +4,8 @@
  * Full terms: see LICENSE.md.
  */
 
+import { type WorkflowEventMap } from '@hexabot-ai/agentic';
+import { ForbiddenException } from '@nestjs/common';
 import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
 import {
   ConnectedSocket,
@@ -19,16 +21,20 @@ import Cookie from 'cookie';
 import signature from 'cookie-signature';
 import { Request } from 'express';
 import { Session as ExpressSession, SessionData } from 'express-session';
-import { Server, Socket } from 'socket.io';
+import { ExtendedError, Server, Socket } from 'socket.io';
 import { sync as uid } from 'uid-safe';
 
-import { MessageFull } from '@/chat/dto/message.dto';
-import { Subscriber, SubscriberFull } from '@/chat/dto/subscriber.dto';
-import { OutgoingMessage, StdEventType } from '@/chat/types/message';
+import { Subscriber } from '@/chat/dto/subscriber.dto';
+import { StdEventType } from '@/chat/types/message';
 import { config } from '@/config';
 import { LoggerService } from '@/logger/logger.service';
+import { PermissionService } from '@/user/services/permission.service';
+import { UserService } from '@/user/services/user.service';
+import { Action } from '@/user/types/action.type';
+import { type TModel } from '@/user/types/model.type';
 import { getSessionMiddleware } from '@/utils/constants/session-middleware';
 import { getSessionStore } from '@/utils/constants/session-store';
+import { type WorkflowContextState } from '@/workflow/types';
 
 import { IOIncomingMessage, IOMessagePipe } from './pipes/io-message.pipe';
 import { SocketEventDispatcherService } from './services/socket-event-dispatcher.service';
@@ -45,63 +51,27 @@ export class WebsocketGateway
     private readonly logger: LoggerService,
     private readonly eventEmitter: EventEmitter2,
     private readonly socketEventDispatcherService: SocketEventDispatcherService,
+    private readonly userService: UserService,
+    private readonly permissionService: PermissionService,
   ) {}
 
   @WebSocketServer() io: Server;
 
-  broadcastMessageSent(message: OutgoingMessage): void {
-    this.io.to(Room.MESSAGE).emit('message', {
-      op: 'messageSent',
-      speakerId: message.recipient,
-      msg: message,
-    });
-  }
-
-  broadcastMessageReceived(
-    message: MessageFull,
-    subscriber: Subscriber | SubscriberFull,
-  ): void {
-    this.io.to(Room.MESSAGE).emit('message', {
-      op: 'messageReceived',
-      speakerId: subscriber.id,
-      msg: message,
-    });
-  }
-
-  broadcastMessageDelivered(
-    deliveredMessages: string[],
-    subscriber: Subscriber | SubscriberFull,
-  ): void {
-    this.io.to(Room.MESSAGE).emit('message', {
-      op: 'messageDelivered',
-      speakerId: subscriber.id,
-      mids: deliveredMessages,
-    });
-  }
-
-  broadcastMessageRead(
-    watermark: number,
-    subscriber: Subscriber | SubscriberFull,
-  ): void {
-    this.io.to(Room.MESSAGE).emit('message', {
-      op: 'messageRead',
-      speakerId: subscriber.id,
-      watermark,
-    });
-  }
-
-  broadcastSubscriberNew(subscriber: Subscriber | SubscriberFull) {
-    this.io.to(Room.SUBSCRIBER).emit('subscriber', {
-      op: 'newSubscriber',
-      profile: subscriber,
-    });
-  }
-
-  broadcastSubscriberUpdate(subscriber: Subscriber | SubscriberFull): void {
-    this.io.to(Room.SUBSCRIBER).emit('subscriber', {
-      op: 'updateSubscriber',
-      profile: subscriber,
-    });
+  broadcastWorkflowEvent({
+    initiatorId,
+    ...rest
+  }: WorkflowEventMap[keyof WorkflowEventMap] &
+    Partial<Pick<WorkflowContextState, 'initiatorId'>> & {
+      workflowId: string;
+      threadId?: string;
+      workflowEvent: string;
+      t: number;
+    }): void {
+    const roomName = initiatorId
+      ? `${Room.WORKFLOW}_${initiatorId}`
+      : Room.WORKFLOW;
+
+    this.io.to(roomName).emit('workflow', rest);
   }
 
   broadcast(
@@ -110,7 +80,28 @@ export class WebsocketGateway
     content: any,
     excludedRooms: string[] = [],
   ) {
-    this.io.to(subscriber.foreign_id).except(excludedRooms).emit(type, content);
+    this.io.to(subscriber.foreignId).except(excludedRooms).emit(type, content);
+  }
+
+  /**
+   * Returns currently connected authenticated user IDs (deduplicated).
+   */
+  getConnectedAuthenticatedUserIds(): string[] {
+    if (!this.io?.sockets?.sockets) {
+      return [];
+    }
+
+    const connectedUserIds = new Set<string>();
+
+    for (const [, socket] of this.io.sockets.sockets) {
+      const userId = socket.request?.session?.passport?.user?.id;
+
+      if (typeof userId === 'string' && userId.trim()) {
+        connectedUserIds.add(userId);
+      }
+    }
+
+    return Array.from(connectedUserIds);
   }
 
   async createAndStoreSession(client: Socket): Promise<void> {
@@ -223,7 +214,7 @@ export class WebsocketGateway
           next();
         } else if (
           // Or, the WS connection is established with a chat widget using the web channel (subscriber)
-          searchParams.get('channel') === 'web-channel'
+          searchParams.get('channel') === 'web'
         ) {
           session.anonymous =
             typeof session.anonymous === 'undefined' ? true : session.anonymous;
@@ -238,7 +229,7 @@ export class WebsocketGateway
         }
       } catch (e) {
         this.logger.warn('Something unexpected happening');
-        next(e);
+        next(e as ExtendedError);
       }
     });
   }
@@ -285,138 +276,136 @@ export class WebsocketGateway
     return { event: 'event', data: 'OK' };
   }
 
-  @SubscribeMessage('get')
-  handleGet(
-    @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
-    @ConnectedSocket() client: Socket,
+  private async dispatchSocketMessage(
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'head',
+    payload: IOIncomingMessage,
+    client: Socket,
   ) {
-    const request = new SocketRequest(client, 'get', payload);
+    const request = new SocketRequest(client, method, payload);
     const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'get',
+    await this.socketEventDispatcherService.handleEvent(
+      method,
       payload.url,
       request,
       response,
     );
 
-    return response.getPromise();
+    return await response.getPromise();
   }
 
-  @SubscribeMessage('post')
-  handlePost(
+  @SubscribeMessage('get')
+  async handleGet(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'post', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'post',
-      payload.url,
-      request,
-      response,
-    );
+    return await this.dispatchSocketMessage('get', payload, client);
+  }
 
-    return response.getPromise();
+  @SubscribeMessage('post')
+  async handlePost(
+    @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
+    @ConnectedSocket() client: Socket,
+  ) {
+    return await this.dispatchSocketMessage('post', payload, client);
   }
 
   @SubscribeMessage('put')
-  handlePut(
+  async handlePut(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'put', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'put',
-      payload.url,
-      request,
-      response,
-    );
-
-    return response.getPromise();
+    return await this.dispatchSocketMessage('put', payload, client);
   }
 
   @SubscribeMessage('patch')
-  handlePatch(
+  async handlePatch(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'patch', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'patch',
-      payload.url,
-      request,
-      response,
-    );
-
-    return response.getPromise();
+    return await this.dispatchSocketMessage('patch', payload, client);
   }
 
   @SubscribeMessage('delete')
-  handleDelete(
+  async handleDelete(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'delete', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'delete',
-      payload.url,
-      request,
-      response,
-    );
-
-    return response.getPromise();
+    return await this.dispatchSocketMessage('delete', payload, client);
   }
 
   @SubscribeMessage('options')
-  handleOptions(
+  async handleOptions(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'options', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'options',
-      payload.url,
-      request,
-      response,
-    );
-
-    return response.getPromise();
+    return await this.dispatchSocketMessage('options', payload, client);
   }
 
   @SubscribeMessage('head')
-  handleHead(
+  async handleHead(
     @MessageBody(new IOMessagePipe()) payload: IOIncomingMessage,
     @ConnectedSocket() client: Socket,
   ) {
-    const request = new SocketRequest(client, 'head', payload);
-    const response = new SocketResponse();
-    this.socketEventDispatcherService.handleEvent(
-      'head',
-      payload.url,
-      request,
-      response,
-    );
+    return await this.dispatchSocketMessage('head', payload, client);
+  }
 
-    return response.getPromise();
+  /**
+   * Determines if a user has permission to perform a specific action.
+   *
+   * @param userId - The user id
+   * @param model - The model
+   * @param action - The action
+   */
+  async hasAbility(userId: string, model: TModel, action: Action) {
+    const user = await this.userService.findOne(userId);
+    const roleIds = user?.roles || [];
+    const permissions = await this.permissionService.getPermissions();
+
+    if (permissions) {
+      const permissionsFromRoles = Object.entries(permissions)
+        .filter(([key, _]) => roleIds.includes(key))
+        .map(([_, value]) => value);
+
+      if (
+        model &&
+        permissionsFromRoles.some((permission) =>
+          permission[model]?.includes(action),
+        )
+      ) {
+        return true;
+      }
+    }
   }
 
   /**
-   * Allows a given socket to join a notification room.
+   * Allows a given socket to join a room.
    *
    * @param req - Socket request
    * @param room - The room name
    */
-  async joinNotificationSockets(req: SocketRequest, room: Room): Promise<void> {
-    if (!req.session.passport?.user?.id) {
+  async joinSockets<R extends Room>(
+    req: SocketRequest,
+    room: R,
+    model?: TModel,
+  ) {
+    const userId = req.session.passport?.user?.id;
+    if (!userId) {
       throw new Error(
-        'Only authenticated users are allowed to join notification rooms!',
+        'Only authenticated users are allowed to join workflow rooms!',
       );
     }
 
-    return await req.socket.join(room);
+    const hasAbility = model
+      ? await this.hasAbility(userId, model, Action.READ)
+      : false;
+
+    if (!hasAbility) {
+      throw new ForbiddenException('You are not authorized to subscribe!');
+    }
+    const roomId = `${room}_${userId}` as const;
+
+    await req.socket.join(roomId);
+
+    return roomId;
   }
 }

package/src/websocket/websocket.module.ts

@@ -6,11 +6,14 @@
 
 import { Global, Module } from '@nestjs/common';
 
+import { UserModule } from '@/user/user.module';
+
 import { SocketEventDispatcherService } from './services/socket-event-dispatcher.service';
 import { WebsocketGateway } from './websocket.gateway';
 
 @Global()
 @Module({
+  imports: [UserModule],
   providers: [WebsocketGateway, SocketEventDispatcherService],
   exports: [WebsocketGateway],
 })

package/src/workflow/contexts/conversational-workflow.context.ts

@@ -0,0 +1,16 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Injectable, Scope } from '@nestjs/common';
+
+import { MessageInboundEvent } from '@/channel/lib/inbound-events';
+
+import { WorkflowRuntimeContext } from './workflow-runtime.context';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class ConversationalWorkflowContext extends WorkflowRuntimeContext<MessageInboundEvent> {
+  event: MessageInboundEvent;
+}

package/src/workflow/contexts/manual-workflow.context.ts

@@ -0,0 +1,16 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Injectable, Scope } from '@nestjs/common';
+
+import { ManualEventWrapper } from '../lib/trigger-event-wrapper';
+
+import { WorkflowRuntimeContext } from './workflow-runtime.context';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class ManualWorkflowContext extends WorkflowRuntimeContext<ManualEventWrapper> {
+  event: ManualEventWrapper;
+}

package/src/workflow/contexts/scheduled-workflow.context.ts

@@ -0,0 +1,16 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Injectable, Scope } from '@nestjs/common';
+
+import { ScheduledEventWrapper } from '../lib/trigger-event-wrapper';
+
+import { WorkflowRuntimeContext } from './workflow-runtime.context';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class ScheduledWorkflowContext extends WorkflowRuntimeContext<ScheduledEventWrapper> {
+  event: ScheduledEventWrapper;
+}

package/src/workflow/contexts/workflow-context-factory.ts

@@ -0,0 +1,78 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import type { WorkflowDefinition } from '@hexabot-ai/agentic';
+import { Injectable, Type } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+
+import { WorkflowRunFull } from '../dto/workflow-run.dto';
+import { TriggerEventWrapper } from '../lib/trigger-event-wrapper';
+import { MemoryService } from '../services/memory.service';
+import { WorkflowType } from '../types';
+
+import { ConversationalWorkflowContext } from './conversational-workflow.context';
+import { ManualWorkflowContext } from './manual-workflow.context';
+import { ScheduledWorkflowContext } from './scheduled-workflow.context';
+import { WorkflowRuntimeContext } from './workflow-runtime.context';
+
+@Injectable()
+export class WorkflowContextFactory {
+  private readonly map: Record<WorkflowType, Type<WorkflowRuntimeContext>> = {
+    [WorkflowType.conversational]: ConversationalWorkflowContext,
+    [WorkflowType.manual]: ManualWorkflowContext,
+    [WorkflowType.scheduled]: ScheduledWorkflowContext,
+  };
+
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly memoryService: MemoryService,
+  ) {}
+
+  private extractMemoryDefinitionIds(
+    definition?: WorkflowDefinition,
+  ): string[] {
+    if (!definition?.defs) {
+      return [];
+    }
+
+    const ids = Object.values(definition.defs)
+      .filter((def) => def?.kind === 'memory')
+      .map(
+        (def) =>
+          (def as { settings?: { definition_id?: unknown } }).settings
+            ?.definition_id,
+      )
+      .filter((value): value is string => typeof value === 'string' && !!value);
+
+    return Array.from(new Set(ids));
+  }
+
+  async create<E extends TriggerEventWrapper>(
+    run: WorkflowRunFull,
+    event: E,
+    definition?: WorkflowDefinition,
+  ): Promise<WorkflowRuntimeContext<E>> {
+    const Ctx = this.map[event.triggerType];
+    if (!Ctx) {
+      throw new Error(`Unsupported triggerType: ${event.triggerType}`);
+    }
+
+    const ctx = await this.moduleRef.resolve<WorkflowRuntimeContext<E>>(Ctx);
+    const memoryDefinitionIds = this.extractMemoryDefinitionIds(definition);
+    const memory = await this.memoryService.buildStore(
+      {
+        ownerId: run.triggeredBy.id,
+        workflowId: run.workflow.id,
+        threadId: run.thread?.id ?? null,
+        runId: run.id,
+        memoryDefinitionIds,
+      },
+      ctx,
+    );
+
+    return await ctx.buildFromRun(run, event, memory);
+  }
+}