@hexabot-ai/api 3.1.4-alpha.0 → 3.2.0-alpha.0

package/src/utils/test/fixtures/subscriber.ts

@@ -4,9 +4,11 @@
  * Full terms: see LICENSE.md.
  */
 
+import { Subscriber } from '@hexabot-ai/types';
 import { DataSource } from 'typeorm';
 
-import { Subscriber, SubscriberCreateDto } from '@/chat/dto/subscriber.dto';
+import { SourceOrmEntity } from '@/channel/entities/source.entity';
+import { SubscriberCreateDto } from '@/chat/dto/subscriber.dto';
 import { LabelOrmEntity } from '@/chat/entities/label.entity';
 import { SubscriberOrmEntity } from '@/chat/entities/subscriber.entity';
 import { EUserProfileType } from '@/user/entities/user-profile.entity';
@@ -31,6 +33,7 @@ export const subscriberDefaultValues: TSubscriberFixtures['defaultValues'] = {
 
 const subscribers: TSubscriberFixtures['values'][] = [
   {
+    source: '11111111-1111-4111-8111-111111111111',
     foreignId: 'foreign-id-messenger',
     firstName: 'Jhon',
     lastName: 'Doe',
@@ -46,6 +49,7 @@ const subscribers: TSubscriberFixtures['values'][] = [
     retainedFrom: new Date('2020-01-01T20:40:03.249Z'),
   },
   {
+    source: '22222222-2222-4222-8222-222222222222',
     foreignId: 'foreign-id-web-1',
     firstName: 'Maynard',
     lastName: 'James Keenan',
@@ -61,6 +65,7 @@ const subscribers: TSubscriberFixtures['values'][] = [
     retainedFrom: new Date('2021-01-02T20:40:03.249Z'),
   },
   {
+    source: '33333333-3333-4333-8333-333333333333',
     foreignId: 'foreign-id-web-2',
     firstName: 'Queen',
     lastName: 'Elisabeth',
@@ -76,6 +81,7 @@ const subscribers: TSubscriberFixtures['values'][] = [
     retainedFrom: new Date('2022-01-02T20:40:03.249Z'),
   },
   {
+    source: '44444444-4444-4444-8444-444444444444',
     foreignId: 'foreign-id-dimelo',
     firstName: 'Carl',
     lastName: 'Jung',
@@ -103,7 +109,7 @@ const findSubscriberRelations = async (dataSource: DataSource) => {
   const repository = dataSource.getRepository(SubscriberOrmEntity);
 
   return await repository.find({
-    relations: ['labels', 'assignedTo', 'avatar'],
+    relations: ['labels', 'assignedTo', 'avatar', 'source'],
   });
 };
 const findLabelRelations = async (
@@ -118,10 +124,43 @@ export const installSubscriberFixturesTypeOrm = async (
   dataSource: DataSource,
 ) => {
   const subscriberRepository = dataSource.getRepository(SubscriberOrmEntity);
+  const sourceRepository = dataSource.getRepository(SourceOrmEntity);
   const [users, labelEntities] = await Promise.all([
     installUserFixturesTypeOrm(dataSource),
     installLabelFixturesTypeOrm(dataSource),
   ]);
+  const channelNames = Array.from(
+    new Set(
+      subscriberFixtures
+        .map((fixture) => fixture.channel?.name)
+        .filter(
+          (name): name is string =>
+            typeof name === 'string' && name.trim().length > 0,
+        ),
+    ),
+  );
+  const sourceIdByChannel = new Map<string, string>();
+
+  for (const channelName of channelNames) {
+    const sourceName = `fixture-source-${channelName}`;
+    let source = await sourceRepository.findOne({
+      where: { name: sourceName },
+    });
+
+    if (!source) {
+      source = await sourceRepository.save(
+        sourceRepository.create({
+          name: sourceName,
+          channel: channelName,
+          settings: {},
+          state: true,
+          defaultWorkflow: null,
+        }),
+      );
+    }
+
+    sourceIdByChannel.set(channelName, source.id);
+  }
 
   if (
     await subscriberRepository.count({
@@ -142,8 +181,17 @@ export const installSubscriberFixturesTypeOrm = async (
       labels: _labels,
       assignedTo: _assignedTo,
       avatar: _avatar,
+      source: _source,
       ...rest
     } = fixture;
+    const channelName = rest.channel?.name;
+    if (!channelName) {
+      throw new Error('Missing fixture channel while seeding subscribers');
+    }
+    const sourceId = sourceIdByChannel.get(channelName);
+    if (!sourceId) {
+      throw new Error(`Missing fixture source for channel ${channelName}`);
+    }
     const entity = new SubscriberOrmEntity();
     Object.assign(entity, {
       ...rest,
@@ -162,6 +210,7 @@ export const installSubscriberFixturesTypeOrm = async (
         ? ({ id: assignedUser.id } as Pick<UserOrmEntity, 'id'>)
         : null,
       avatar: _avatar ? ({ id: _avatar } as { id: string }) : null,
+      source: { id: sourceId } as Pick<SourceOrmEntity, 'id'> & SourceOrmEntity,
     });
 
     await subscriberRepository.save(entity);

package/src/utils/test/fixtures/user.ts

@@ -4,9 +4,10 @@
  * Full terms: see LICENSE.md.
  */
 
+import type { User } from '@hexabot-ai/types';
 import { DataSource } from 'typeorm';
 
-import { User, UserCreateDto } from '@/user/dto/user.dto';
+import { UserCreateDto } from '@/user/dto/user.dto';
 import { RoleOrmEntity } from '@/user/entities/role.entity';
 import { UserOrmEntity } from '@/user/entities/user.entity';
 import { hash } from '@/user/utilities/bcryptjs';

package/src/utils/test/mocks/subscriber.ts

@@ -4,8 +4,9 @@
  * Full terms: see LICENSE.md.
  */
 
+import { Subscriber, SubscriberFull } from '@hexabot-ai/types';
+
 import { customerLabelsMock } from '@/channel/lib/__test__/label.mock';
-import { Subscriber, SubscriberFull } from '@/chat/dto/subscriber.dto';
 
 import { modelInstance } from './misc';
 
@@ -27,6 +28,7 @@ export const subscriberInstance: Subscriber = {
   },
   labels: [],
   avatar: null,
+  source: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
   ...modelInstance,
 };
 
@@ -40,4 +42,14 @@ export const subscriberWithLabels: SubscriberFull = {
   labels: customerLabelsMock,
   assignedTo: null,
   avatar: null,
+  source: {
+    id: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+    name: 'fixture-source-web',
+    channel: 'web',
+    settings: {},
+    state: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    defaultWorkflow: null,
+  },
 };

package/src/utils/types/dto.types.ts

@@ -4,30 +4,10 @@
  * Full terms: see LICENSE.md.
  */
 
-import { Exclude, Expose } from 'class-transformer';
+import type { ZodTypeAny } from 'zod';
 
 import { BaseOrmEntity } from '@/database/entities/base.entity';
 
-export type Ctor<T = unknown> = abstract new (...args: any[]) => T;
-
-@Exclude()
-export class BaseIdStub {
-  @Expose()
-  id!: string;
-}
-
-@Exclude()
-export class BaseStub extends BaseIdStub {
-  @Expose()
-  id!: string;
-
-  @Expose()
-  createdAt!: Date;
-
-  @Expose()
-  updatedAt!: Date;
-}
-
 export enum DtoType {
   PLAIN = 'plain',
   FULL = 'full',
@@ -56,6 +36,16 @@ export type TDto<
   actions extends TDtoAction = TDtoAction,
 > = { transformers: transformers; actions: actions };
 
+export type TZodDto<
+  transformers extends {
+    [K in DtoType]: ZodTypeAny;
+  } = {
+    plain: ZodTypeAny;
+    full: ZodTypeAny;
+  },
+  actions extends TDtoAction = TDtoAction,
+> = TDto<transformers, actions>;
+
 export type TEntityDto<Entity extends BaseOrmEntity> = TDto<
   {
     plain: Entity['plainCls'];
@@ -80,11 +70,7 @@ export type InferUpdateDto<Entity extends BaseOrmEntity<TEntityDto<Entity>>> =
 export type InferActionsDto<Entity extends BaseOrmEntity<TEntityDto<Entity>>> =
   Entity['__dtoType']['actions'];
 
-export type InferTransformDto<T> = T extends new (...args: unknown[]) => infer R
-  ? R
-  : T extends { prototype: infer P }
-    ? P
-    : unknown;
+export type InferTransformDto<T> = T extends ZodTypeAny ? T['_output'] : never;
 
 export type InferPlain<Entity extends BaseOrmEntity<TEntityDto<Entity>>> =
   InferTransformDto<Entity['plainCls']>;

package/src/websocket/services/socket-event-dispatcher.service.ts

@@ -18,6 +18,7 @@ import { Mutex } from 'async-mutex';
 import { Socket } from 'socket.io';
 
 import { AppInstance } from '@/app.instance';
+import { config } from '@/config';
 import { LoggerService } from '@/logger/logger.service';
 
 import { SocketEventMetadataStorage } from '../storage/socket-event-metadata.storage';
@@ -36,6 +37,8 @@ export class SocketEventDispatcherService implements OnModuleInit {
     put: new Map(),
     patch: new Map(),
     delete: new Map(),
+    options: new Map(),
+    head: new Map(),
   };
 
   constructor(
@@ -51,7 +54,7 @@ export class SocketEventDispatcherService implements OnModuleInit {
 
   async handleEvent(
     socketMethod: SocketMethod,
-    path: string,
+    _path: string,
     req: SocketRequest,
     res: SocketResponse,
   ) {
@@ -61,12 +64,24 @@ export class SocketEventDispatcherService implements OnModuleInit {
 
     try {
       const handlers = this.routeHandlers[socketMethod];
-      const foundHandler = Array.from(handlers.entries()).find(([key, _]) => {
-        const urlPathname = new URL(req.url, 'http://localhost').pathname;
-        const keyUrlPathName = new URL(key, 'http://localhost').pathname;
+      if (!handlers) {
+        return res.status(HttpStatus.NOT_FOUND).send({ message: 'Not Found' });
+      }
 
-        return urlPathname === keyUrlPathName;
-      });
+      const incomingPath = this.normalizeIncomingPath(req.path);
+      const foundHandler = Array.from(handlers.entries()).find(
+        ([routePath, _]) => {
+          const params = this.matchPath(routePath, incomingPath);
+
+          if (!params) {
+            return false;
+          }
+
+          req.params = params;
+
+          return true;
+        },
+      );
 
       if (!foundHandler) {
         return res.status(HttpStatus.NOT_FOUND).send({ message: 'Not Found' });
@@ -106,6 +121,75 @@ export class SocketEventDispatcherService implements OnModuleInit {
     }
   }
 
+  private normalizeIncomingPath(path: string): string {
+    const normalizedPath = this.normalizePath(path);
+    const apiPrefix = this.normalizePath(new URL(config.apiBaseUrl).pathname);
+
+    if (
+      apiPrefix !== '/' &&
+      (normalizedPath === apiPrefix ||
+        normalizedPath.startsWith(`${apiPrefix}/`))
+    ) {
+      const withoutPrefix = normalizedPath.slice(apiPrefix.length) || '/';
+
+      return this.normalizePath(withoutPrefix);
+    }
+
+    return normalizedPath;
+  }
+
+  private normalizePath(path: string): string {
+    if (!path || path === '/') {
+      return '/';
+    }
+
+    const withLeadingSlash = path.startsWith('/') ? path : `/${path}`;
+    const withoutTrailingSlash =
+      withLeadingSlash.length > 1
+        ? withLeadingSlash.replace(/\/+$/, '')
+        : withLeadingSlash;
+
+    return withoutTrailingSlash;
+  }
+
+  private matchPath(
+    pattern: string,
+    path: string,
+  ): Record<string, string> | null {
+    const normalizedPattern = this.normalizePath(pattern);
+    const normalizedPath = this.normalizePath(path);
+    const patternSegments = normalizedPattern.split('/').filter(Boolean);
+    const pathSegments = normalizedPath.split('/').filter(Boolean);
+
+    if (patternSegments.length !== pathSegments.length) {
+      return null;
+    }
+
+    const params: Record<string, string> = {};
+
+    for (let i = 0; i < patternSegments.length; i += 1) {
+      const patternSegment = patternSegments[i];
+      const pathSegment = pathSegments[i];
+
+      if (patternSegment.startsWith(':')) {
+        const paramName = patternSegment.slice(1);
+
+        if (!paramName) {
+          return null;
+        }
+
+        params[paramName] = decodeURIComponent(pathSegment);
+        continue;
+      }
+
+      if (patternSegment !== pathSegment) {
+        return null;
+      }
+    }
+
+    return params;
+  }
+
   onModuleInit() {
     if (!AppInstance.isReady()) {
       return;

package/src/websocket/utils/socket-request.ts

@@ -6,10 +6,10 @@
 
 // Import required modules and configurations
 
+import type { User } from '@hexabot-ai/types';
 import { Socket } from 'socket.io';
 
 import { config } from '@/config';
-import { User } from '@/user/dto/user.dto';
 
 import { IOIncomingMessage } from '../pipes/io-message.pipe';
 
@@ -38,6 +38,8 @@ export class SocketRequest {
 
   query: Record<string, any>;
 
+  params: Record<string, string>;
+
   // Request specifics
   method: string;
 
@@ -97,6 +99,7 @@ export class SocketRequest {
       ...socket.handshake.query,
       ...urlQuery,
     };
+    this.params = {};
 
     // Set the HTTP method and the body of the request
     this.method = method.toUpperCase();

package/src/websocket/websocket.gateway.ts

@@ -5,7 +5,8 @@
  */
 
 import { type WorkflowEventMap } from '@hexabot-ai/agentic';
-import { ForbiddenException } from '@nestjs/common';
+import { StdEventType, Subscriber } from '@hexabot-ai/types';
+import { ForbiddenException, Optional } from '@nestjs/common';
 import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
 import {
   ConnectedSocket,
@@ -22,11 +23,14 @@ import signature from 'cookie-signature';
 import { Request } from 'express';
 import { Session as ExpressSession, SessionData } from 'express-session';
 import { ExtendedError, Server, Socket } from 'socket.io';
+import { DataSource } from 'typeorm';
 import { sync as uid } from 'uid-safe';
+import { validate as isUuid } from 'uuid';
 
-import { Subscriber } from '@/chat/dto/subscriber.dto';
-import { StdEventType } from '@/chat/types/message';
+import { SourceOrmEntity } from '@/channel/entities/source.entity';
 import { config } from '@/config';
+import { CONSOLE_CHANNEL_NAME } from '@/extensions/channels/console/settings.schema';
+import { WEB_CHANNEL_NAME } from '@/extensions/channels/web/settings.schema';
 import { LoggerService } from '@/logger/logger.service';
 import { PermissionService } from '@/user/services/permission.service';
 import { UserService } from '@/user/services/user.service';
@@ -53,6 +57,7 @@ export class WebsocketGateway
     private readonly socketEventDispatcherService: SocketEventDispatcherService,
     private readonly userService: UserService,
     private readonly permissionService: PermissionService,
+    @Optional() private readonly dataSource?: DataSource,
   ) {}
 
   @WebSocketServer() io: Server;
@@ -80,6 +85,10 @@ export class WebsocketGateway
     content: any,
     excludedRooms: string[] = [],
   ) {
+    if (!subscriber.foreignId) {
+      return;
+    }
+
     this.io.to(subscriber.foreignId).except(excludedRooms).emit(type, content);
   }
 
@@ -169,6 +178,29 @@ export class WebsocketGateway
     });
   }
 
+  private normalizeSourceId(value: string | null): string | null {
+    if (!value || !isUuid(value)) {
+      return null;
+    }
+
+    return value;
+  }
+
+  private async findActiveSource(
+    sourceId: string,
+  ): Promise<SourceOrmEntity | null> {
+    if (!this.dataSource) {
+      return null;
+    }
+
+    return await this.dataSource.getRepository(SourceOrmEntity).findOne({
+      where: {
+        id: sourceId,
+        state: true,
+      },
+    });
+  }
+
   afterInit(): void {
     this.logger.log('Initialized websocket gateway');
 
@@ -207,14 +239,61 @@ export class WebsocketGateway
           return;
         }
         const session = client.request.session;
+        const rawSourceId = searchParams.get('source_id');
+        const sourceId = this.normalizeSourceId(rawSourceId);
+        const userId = session.passport?.user?.id;
+
+        if (!rawSourceId && userId) {
+          // Core websocket connection for system notifications (not the web/console channel one)
+          next();
+
+          return;
+        }
+
+        if (!sourceId) {
+          next(
+            new Error('Missing or invalid source_id in websocket handshake'),
+          );
+
+          return;
+        }
+
+        const source = await this.findActiveSource(sourceId);
+
+        if (!source) {
+          next(new Error('Source is not available'));
+
+          return;
+        }
+
+        const isWebCompatibleSource =
+          source.channel === WEB_CHANNEL_NAME ||
+          source.channel === CONSOLE_CHANNEL_NAME;
+
+        if (!isWebCompatibleSource) {
+          next(new Error('Source channel is not compatible with websocket'));
+
+          return;
+        }
+
+        session.web = {
+          ...session.web,
+          sourceId: source.id,
+        };
+
         if (
           // Either the WS connection is with an authenticated user
-          session.passport?.user?.id
+          userId
         ) {
+          session.save((err) => {
+            if (err) {
+              this.logger.error('WS : Unable to save session!', err);
+            }
+          });
           next();
         } else if (
           // Or, the WS connection is established with a chat widget using the web channel (subscriber)
-          searchParams.get('channel') === 'web'
+          source.channel === WEB_CHANNEL_NAME
         ) {
           session.anonymous =
             typeof session.anonymous === 'undefined' ? true : session.anonymous;

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

@@ -5,10 +5,10 @@
  */
 
 import type { WorkflowDefinition } from '@hexabot-ai/agentic';
+import { WorkflowRunFull } from '@hexabot-ai/types';
 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';
@@ -62,9 +62,13 @@ export class WorkflowContextFactory {
 
     const ctx = await this.moduleRef.resolve<WorkflowRuntimeContext<E>>(Ctx);
     const memoryDefinitionIds = this.extractMemoryDefinitionIds(definition);
+    const triggeredById = run.triggeredBy?.id;
+    if (!triggeredById) {
+      throw new Error(`Workflow run ${run.id} is missing triggeredBy`);
+    }
     const memory = await this.memoryService.buildStore(
       {
-        ownerId: run.triggeredBy.id,
+        ownerId: triggeredById,
         workflowId: run.workflow.id,
         threadId: run.thread?.id ?? null,
         runId: run.id,

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

@@ -5,6 +5,7 @@
  */
 
 import { BaseWorkflowContext } from '@hexabot-ai/agentic';
+import { WorkflowRunFull } from '@hexabot-ai/types';
 import { forwardRef, Inject, Injectable, Scope } from '@nestjs/common';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 
@@ -18,7 +19,6 @@ import { LoggerService } from '@/logger/logger.service';
 import { SettingService } from '@/setting/services/setting.service';
 import { CredentialService } from '@/user';
 import { cloneObject } from '@/utils/helpers/clone';
-import type { WorkflowRunFull } from '@/workflow/dto/workflow-run.dto';
 import { WorkflowContextState, WorkflowType } from '@/workflow/types';
 
 import { TriggerEventWrapper } from '../lib/trigger-event-wrapper';
@@ -137,7 +137,11 @@ export abstract class WorkflowRuntimeContext<
     // Hydrate persisted state first, then merge transient event context.
     await this.hydrate(run.context);
     await this.hydrate(event.getContextData());
-    this.initiatorId = run.triggeredBy.id;
+    const triggeredById = run.triggeredBy?.id;
+    if (!triggeredById) {
+      throw new Error(`Workflow run ${run.id} is missing triggeredBy`);
+    }
+    this.initiatorId = triggeredById;
     this.workflowId = run.workflow.id;
     this.workflowRunId = run.id;
     this.threadId = run.thread?.id ?? event.getThreadId() ?? null;

package/src/workflow/controllers/mcp-server.controller.ts

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
+import { McpServer, McpServerFull } from '@hexabot-ai/types';
 import {
   Body,
   Controller,
@@ -22,12 +23,7 @@ import { PopulatePipe, UuidParam } from '@/utils';
 import { BaseOrmController } from '@/utils/generics/base-orm.controller';
 import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
 
-import {
-  McpServer,
-  McpServerCreateDto,
-  McpServerFull,
-  McpServerUpdateDto,
-} from '../dto/mcp-server.dto';
+import { McpServerCreateDto, McpServerUpdateDto } from '../dto/mcp-server.dto';
 import { McpServerOrmEntity } from '../entities/mcp-server.entity';
 import {
   McpServerDiagnostics,

package/src/workflow/controllers/memory-definition.controller.ts

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
+import { MemoryDefinition } from '@hexabot-ai/types';
 import {
   Body,
   Controller,
@@ -23,7 +24,6 @@ import { BaseOrmController } from '@/utils/generics/base-orm.controller';
 import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
 
 import {
-  MemoryDefinition,
   MemoryDefinitionCreateDto,
   MemoryDefinitionUpdateDto,
 } from '../dto/memory-definition.dto';

package/src/workflow/controllers/workflow-run.controller.ts

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
+import { WorkflowRun, WorkflowRunFull } from '@hexabot-ai/types';
 import { Controller, Get, Query } from '@nestjs/common';
 import { FindManyOptions } from 'typeorm';
 
@@ -12,7 +13,6 @@ import { BaseOrmController } from '@/utils/generics/base-orm.controller';
 import { PopulatePipe } from '@/utils/pipes/populate.pipe';
 import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';
 
-import { WorkflowRun, WorkflowRunFull } from '../dto/workflow-run.dto';
 import { WorkflowRunOrmEntity } from '../entities/workflow-run.entity';
 import { WorkflowRunService } from '../services/workflow-run.service';
 

package/src/workflow/controllers/workflow-version.controller.ts

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
+import { WorkflowVersion } from '@hexabot-ai/types';
 import {
   Body,
   Controller,
@@ -24,7 +25,6 @@ import { PopulatePipe } from '@/utils/pipes/populate.pipe';
 
 import {
   WorkflowNewVersionDto,
-  WorkflowVersion,
   WorkflowVersionUpdateDto,
 } from '../dto/workflow-version.dto';
 import { WorkflowVersionOrmEntity } from '../entities/workflow-version.entity';