@erxes/api-shared 0.0.0-stage → 3.2.19-2

package/src/core-types/modules/products/productConfig.ts

@@ -0,0 +1,10 @@
+import { Document } from 'mongoose';
+
+export interface IProductsConfig {
+  code: string;
+  value: any;
+}
+
+export interface IProductsConfigDocument extends IProductsConfig, Document {
+  _id: string;
+}

package/src/core-types/modules/products/uom.ts

@@ -0,0 +1,12 @@
+import { Document } from 'mongoose';
+
+export interface IUom {
+  code: string;
+  name: string;
+  timely?: string;
+}
+
+export interface IUomDocument extends IUom, Document {
+  _id: string;
+  createdAt: Date;
+}

package/src/core-types/modules/relations/relations.ts

@@ -0,0 +1,14 @@
+import { Document } from 'mongoose';
+
+export interface IRelation {
+  entities: {
+    contentType: string;
+    contentId: string;
+  }[];
+}
+
+export interface IRelationDocument extends IRelation, Document {
+  _id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/core-types/modules/saas/organization.ts

@@ -0,0 +1,7 @@
+export interface IOrganizationCharge {
+  [key: string]: {
+    free: number;
+    purchased: number;
+    used: number;
+  };
+}

package/src/core-types/modules/structure/structure.ts

@@ -0,0 +1,29 @@
+import { Document } from 'mongoose';
+
+export interface IStructureCommonTypes {
+  title: string;
+  description?: string;
+  supervisorId?: string;
+  parentId?: string;
+  code: string;
+}
+
+export interface IDepartment extends IStructureCommonTypes {
+  parentId?: string;
+  userIds?: string[];
+  order: string;
+}
+
+export interface IDepartmentDocument extends IDepartment, Document {
+  _id: string;
+}
+export interface IBranch extends IStructureCommonTypes {
+  address?: string;
+  userIds?: string[];
+  radius?: number;
+  order: string;
+}
+
+export interface IBranchDocument extends IBranch, Document {
+  _id: string;
+}

package/src/core-types/modules/tags/tag.ts

@@ -0,0 +1,17 @@
+import { Document } from 'mongoose';
+
+export interface ITag {
+  name: string;
+  colorCode?: string;
+  parentId?: string;
+  relatedIds?: string[];
+  isGroup?: boolean;
+  type: string;
+  objectCount?: number;
+  order?: string;
+}
+
+export interface ITagDocument extends ITag, Document {
+  _id: string;
+  createdAt: Date;
+}

package/src/core-types/modules/team-member/structure.ts

@@ -0,0 +1,23 @@
+
+export interface IBrand {
+  code?: string;
+  name?: string;
+  description?: string;
+  userId?: string;
+  emailConfig?: IBrandEmailConfig;
+}
+
+export interface IBrandDocument extends IBrand, Document {
+  _id: string;
+  emailConfig?: IBrandEmailConfigDocument;
+  createdAt: Date;
+}
+
+export interface IBrandEmailConfig {
+  type?: string;
+  template?: string;
+}
+
+export interface IBrandEmailConfigDocument
+  extends IBrandEmailConfig,
+    Document {}

package/src/core-types/modules/team-member/user.ts

@@ -0,0 +1,93 @@
+import { Document } from 'mongoose';
+import { ICustomField, ILink, IPropertyField } from '../../common';
+
+export interface IEmailSignature {
+  brandId?: string;
+  signature?: string;
+}
+export interface IEmailSignatureDocument extends IEmailSignature, Document {}
+
+export interface ICustomPermission {
+  plugin?: string;
+  module: string;
+  actions: string[];
+  scope: 'own' | 'group' | 'all';
+}
+
+export interface IDetail {
+  avatar?: string;
+  coverPhoto?: string;
+  fullName?: string;
+  shortName?: string;
+  position?: string;
+  birthDate?: Date;
+  workStartedDate?: Date;
+  location?: string;
+  description?: string;
+  operatorPhone?: string;
+  firstName?: string;
+  middleName?: string;
+  lastName?: string;
+}
+
+export interface IUser {
+  createdAt?: Date;
+  username?: string;
+  password: string;
+  resetPasswordToken?: string;
+  resetPasswordExpires?: Date;
+  registrationToken?: string;
+  registrationTokenExpires?: Date;
+  isOwner?: boolean;
+  email?: string;
+  getNotificationByEmail?: boolean;
+  emailSignatures?: IEmailSignature[];
+  starredConversationIds?: string[];
+  details?: IDetail;
+  links?: ILink;
+  isActive?: boolean;
+  brandIds?: string[];
+  groupIds?: string[];
+  deviceTokens?: string[];
+  code?: string;
+  doNotDisturb?: string;
+  isSubscribed?: string;
+  sessionCode?: string;
+  isShowNotification?: boolean;
+  score?: number;
+  customFieldsData?: ICustomField[];
+  propertiesData?: IPropertyField;
+  departmentIds?: string[];
+  branchIds?: string[];
+  positionIds?: string[];
+  employeeId?: string;
+  chatStatus?: IUserChatStatus;
+  lastSeenAt?: Date;
+  onboardedPlugins?: string[];
+  isOnboarded?: boolean;
+  permissionGroupIds?: string[];
+  customPermissions?: ICustomPermission[];
+}
+
+enum IUserChatStatus {
+  online = 'online',
+  offline = 'offline',
+}
+
+export interface IUserDocument extends Omit<IUser, 'links'>, Document {
+  _id: string;
+  emailSignatures?: IEmailSignatureDocument[];
+  details?: IDetail;
+  role?: string;
+  appId?: string;
+}
+export interface IUserMovementDocument extends Document {
+  _id: string;
+  contentType: string;
+  contentTypeId: string;
+  userId: string;
+  createdAt: string;
+  createdBy: string;
+  status: string;
+  isActive: boolean;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export default {};

package/src/utils/agent-tools/auth.ts

@@ -0,0 +1,129 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { IncomingHttpHeaders } from 'node:http';
+
+export const agentToolsAuthHeaderName = 'x-erxes-agent-auth';
+
+// Signed payloads carry an issue timestamp and expire quickly so a captured
+// header cannot be replayed indefinitely inside the internal network.
+const AUTH_TTL_MS = 5 * 60 * 1000;
+
+export interface AgentToolsAuthPayload {
+  subdomain: string;
+  userId: string | null;
+}
+
+/**
+ * Secret used to sign/verify the agent-tools auth header. Every backend
+ * service shares the auth JWT secret, so a header signed by one service
+ * verifies in another.
+ *
+ * There is intentionally NO default value. A hardcoded fallback would let
+ * anyone reproduce the HMAC and re-open the unauthenticated tool-execution
+ * hole this signing is meant to close, so we fail closed: sign/verify throws
+ * until JWT_TOKEN_SECRET is configured.
+ */
+const getAgentToolsSecret = (): string => {
+  const secret = process.env.JWT_TOKEN_SECRET;
+
+  if (!secret || secret.trim() === '') {
+    throw new Error(
+      'JWT_TOKEN_SECRET is required to sign and verify the agent-tools ' +
+        'auth header used for service-to-service authentication. Set ' +
+        'JWT_TOKEN_SECRET to the same value across all backend services.',
+    );
+  }
+
+  return secret;
+};
+
+const signPayload = (payloadBase64: string): string =>
+  createHmac('sha256', getAgentToolsSecret())
+    .update(payloadBase64)
+    .digest('base64url');
+
+/**
+ * Mint a signed agent-tools auth header binding the given tenant (and
+ * optionally the acting user) into a tamper-proof credential.
+ */
+export const encodeAgentToolsAuthHeader = (
+  subdomain: string,
+  userId?: string,
+): string => {
+  const payloadBase64 = Buffer.from(
+    JSON.stringify({ subdomain, userId: userId || null, at: Date.now() }),
+    'utf8',
+  ).toString('base64url');
+
+  return `${payloadBase64}.${signPayload(payloadBase64)}`;
+};
+
+/**
+ * Verify the agent-tools auth header and return the bound identity. Returns
+ * null when the header is missing, malformed, expired, or carries an invalid
+ * signature — callers must treat null as unauthenticated.
+ */
+export const decodeAgentToolsAuthHeader = (
+  headers: IncomingHttpHeaders,
+): AgentToolsAuthPayload | null => {
+  const header = headers[agentToolsAuthHeaderName];
+
+  if (!header || Array.isArray(header)) {
+    return null;
+  }
+
+  const separatorIndex = header.lastIndexOf('.');
+
+  if (separatorIndex === -1) {
+    return null;
+  }
+
+  const payloadBase64 = header.slice(0, separatorIndex);
+  const signature = header.slice(separatorIndex + 1);
+
+  let expectedSignature: string;
+
+  try {
+    expectedSignature = signPayload(payloadBase64);
+  } catch {
+    // Secret not configured — fail closed.
+    return null;
+  }
+
+  const signatureBuffer = Buffer.from(signature);
+  const expectedBuffer = Buffer.from(expectedSignature);
+
+  if (
+    signatureBuffer.length !== expectedBuffer.length ||
+    !timingSafeEqual(signatureBuffer, expectedBuffer)
+  ) {
+    return null;
+  }
+
+  try {
+    const payload = JSON.parse(
+      Buffer.from(payloadBase64, 'base64url').toString('utf8'),
+    );
+
+    if (
+      !payload ||
+      typeof payload.subdomain !== 'string' ||
+      !payload.subdomain
+    ) {
+      return null;
+    }
+
+    if (
+      typeof payload.at !== 'number' ||
+      Math.abs(Date.now() - payload.at) > AUTH_TTL_MS
+    ) {
+      return null;
+    }
+
+    return {
+      subdomain: payload.subdomain,
+      userId: typeof payload.userId === 'string' ? payload.userId : null,
+    };
+  } catch {
+    return null;
+  }
+};

package/src/utils/agent-tools/endpoints.ts

@@ -0,0 +1,274 @@
+import {
+  Application,
+  Request as ApiRequest,
+  Response as ApiResponse,
+} from 'express';
+import { IUserDocument } from '../../core-types';
+import { checkPermissionGroup } from '../../core-modules/permissions/utils';
+import { createPluginTRPCContext, err, ok, sendTRPCMessage } from '../trpc';
+import { decodeAgentToolsAuthHeader } from './auth';
+import { buildAgentToolManifest } from './manifest';
+import {
+  agentToolResponseTooLargeError,
+  getAgentToolMaxResponseBytes,
+  oversizedAgentToolResultBytes,
+} from './responseLimit';
+import {
+  AgentToolManifest,
+  AgentTrpcRouter,
+  AgentTrpcToolDescriptor,
+} from './types';
+
+export interface AgentToolsOptions {
+  plugin: string;
+  // Router and context factory are plugin-defined; typed structurally at this
+  // boundary since plugins construct them dynamically.
+  trpcRouter?: AgentTrpcRouter;
+  createContext?: (
+    subdomain: string,
+    context: Record<string, unknown>,
+  ) => Promise<unknown>;
+  /** Prefixes of tRPC procedure paths to keep out of the manifest. */
+  exclude?: string[];
+}
+
+const MANIFEST_TTL_MS = 60_000;
+
+const manifestCache = new Map<
+  string,
+  { manifest: AgentToolManifest; at: number }
+>();
+
+/** Cache key scoped to the tenant and the full mount configuration. */
+const manifestCacheKey = (
+  subdomain: string,
+  options: AgentToolsOptions,
+): string => JSON.stringify([options.plugin, subdomain, options.exclude || []]);
+
+const getManifest = async (
+  subdomain: string,
+  options: AgentToolsOptions,
+): Promise<AgentToolManifest> => {
+  const cacheKey = manifestCacheKey(subdomain, options);
+  const cached = manifestCache.get(cacheKey);
+
+  if (cached && Date.now() - cached.at < MANIFEST_TTL_MS) {
+    return cached.manifest;
+  }
+
+  const manifest = buildAgentToolManifest({
+    plugin: options.plugin,
+    trpcRouter: options.trpcRouter,
+    exclude: options.exclude || [],
+  });
+
+  manifestCache.set(cacheKey, { manifest, at: Date.now() });
+
+  return manifest;
+};
+
+/** Execute a tRPC tool in-process through the plugin's context factory. */
+const executeTrpcTool = async (
+  options: AgentToolsOptions,
+  subdomain: string,
+  userId: string,
+  descriptor: AgentTrpcToolDescriptor,
+  input: Record<string, unknown> | undefined,
+): Promise<unknown> => {
+  const { trpcRouter, createContext } = options;
+
+  if (!trpcRouter || typeof trpcRouter.createCaller !== 'function') {
+    throw new Error('tRPC router is not available on this plugin');
+  }
+
+  // `__processId` is a reserved key used only for context propagation; the
+  // remaining input object is the procedure input itself.
+  const { __processId, ...procedureInput } = input || {};
+
+  // Reuse the shared /trpc context initialization so request process state
+  // and event handlers behave identically to the public tRPC mount.
+  const pluginContext = await createPluginTRPCContext(
+    subdomain,
+    {
+      userId,
+      processId: typeof __processId === 'string' ? __processId : undefined,
+    },
+    createContext,
+  );
+
+  const caller = trpcRouter.createCaller(pluginContext);
+
+  // tRPC caller proxies are function-valued at every level, so the navigation
+  // must accept functions as well as plain objects.
+  const procedure = descriptor.path
+    .split('.')
+    .reduce<unknown>(
+      (acc, segment) =>
+        acc && (typeof acc === 'object' || typeof acc === 'function')
+          ? (acc as Record<string, unknown>)[segment]
+          : undefined,
+      caller,
+    );
+
+  if (typeof procedure !== 'function') {
+    throw new TypeError(`tRPC procedure '${descriptor.path}' not found`);
+  }
+
+  return await (procedure as (input: unknown) => Promise<unknown>)(
+    input ? procedureInput : undefined,
+  );
+};
+
+/**
+ * Mount the agent capability endpoints on a service. Both endpoints require
+ * the HMAC-signed agent auth header; identity is derived from the signed
+ * payload, never from caller-controlled plain headers.
+ */
+export const mountAgentTools = (
+  app: Application,
+  options: AgentToolsOptions,
+): void => {
+  app.get(
+    '/agent-tools/manifest',
+    async (req: ApiRequest, res: ApiResponse) => {
+      const auth = decodeAgentToolsAuthHeader(req.headers);
+
+      if (!auth?.subdomain) {
+        return res
+          .status(401)
+          .json(err(new Error('Missing or invalid agent auth header')));
+      }
+
+      try {
+        const manifest = await getManifest(auth.subdomain, options);
+
+        return res.json(ok(manifest));
+      } catch (error) {
+        console.error('[agent-tools] manifest error:', error);
+
+        return res
+          .status(500)
+          .json(err(new Error('Failed to build agent tool manifest')));
+      }
+    },
+  );
+
+  app.post('/agent-tools/call', async (req: ApiRequest, res: ApiResponse) => {
+    const auth = decodeAgentToolsAuthHeader(req.headers);
+    const subdomain = auth?.subdomain;
+    const userId = auth?.userId;
+
+    if (!subdomain || !userId) {
+      return res
+        .status(401)
+        .json(err(new Error('Missing or invalid agent auth header')));
+    }
+
+    const { toolId, input } = (req.body || {}) as {
+      toolId?: string;
+      input?: Record<string, unknown>;
+    };
+
+    if (!toolId || typeof toolId !== 'string') {
+      return res
+        .status(400)
+        .json(err(new Error('Missing toolId in request body')));
+    }
+
+    if (
+      input !== undefined &&
+      (typeof input !== 'object' || input === null || Array.isArray(input))
+    ) {
+      return res
+        .status(400)
+        .json(err(new Error('input must be an object when provided')));
+    }
+
+    try {
+      const manifest = await getManifest(subdomain, options);
+      const descriptor = manifest.tools.find((tool) => tool.id === toolId);
+
+      if (!descriptor) {
+        return res
+          .status(404)
+          .json(err(new Error(`Unknown agent tool '${toolId}'`)));
+      }
+
+      // Fail closed: a tool without a declared permission is never callable.
+      if (!descriptor.permission) {
+        return res
+          .status(403)
+          .json(
+            err(
+              new Error(
+                `Agent tool '${toolId}' declares no permission and is not callable`,
+              ),
+            ),
+          );
+      }
+
+      const user = (await sendTRPCMessage({
+        subdomain,
+        pluginName: 'core',
+        module: 'users',
+        action: 'findOne',
+        method: 'query',
+        input: { query: { _id: userId } },
+        defaultValue: null,
+      })) as IUserDocument | null;
+
+      if (!user) {
+        return res
+          .status(403)
+          .json(err(new Error('Forbidden: user not found')));
+      }
+
+      try {
+        await checkPermissionGroup(
+          subdomain,
+          user,
+        )(descriptor.permission.action);
+      } catch (permissionError) {
+        return res.status(403).json(err(permissionError));
+      }
+
+      const result = await executeTrpcTool(
+        options,
+        subdomain,
+        userId,
+        descriptor,
+        input,
+      );
+
+      // Oversized payloads stall the agent run and freeze the chat UI; reject
+      // them with guidance so the model retries with a narrower call.
+      const maxResponseBytes = getAgentToolMaxResponseBytes();
+      const resultBytes = oversizedAgentToolResultBytes(
+        result,
+        maxResponseBytes,
+      );
+
+      if (resultBytes !== null) {
+        return res
+          .status(413)
+          .json(
+            err(
+              agentToolResponseTooLargeError(
+                toolId,
+                resultBytes,
+                maxResponseBytes,
+              ),
+            ),
+          );
+      }
+
+      return res.json(ok(result));
+    } catch (error) {
+      console.error('[agent-tools] call error:', error);
+
+      return res
+        .status(500)
+        .json(err(new Error('Agent tool execution failed')));
+    }
+  });
+};

package/src/utils/agent-tools/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './auth';
+export * from './manifest';
+export * from './endpoints';
+export * from './responseLimit';