Merge branch 'main' into FEATURE/Vision

# Conflicts:
#	packages/components/nodes/chains/ConversationChain/ConversationChain.ts
#	packages/server/src/index.ts
#	packages/server/src/utils/index.ts

packages/server/src/utils/XSS.ts

@@ -18,3 +18,28 @@ export function sanitizeMiddleware(req: Request, res: Response, next: NextFuncti
     }
     next()
 }
+
+export function getAllowedCorsOrigins(): string {
+    // Expects FQDN separated by commas, otherwise nothing or * for all.
+    return process.env.CORS_ORIGINS ?? '*'
+}
+
+export function getCorsOptions(): any {
+    const corsOptions = {
+        origin: function (origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) {
+            const allowedOrigins = getAllowedCorsOrigins()
+            if (!origin || allowedOrigins == '*' || allowedOrigins.indexOf(origin) !== -1) {
+                callback(null, true)
+            } else {
+                callback(null, false)
+            }
+        }
+    }
+    return corsOptions
+}
+
+export function getAllowedIframeOrigins(): string {
+    // Expects FQDN separated by commas, otherwise nothing or * for all.
+    // Also CSP allowed values: self or none
+    return process.env.IFRAME_ORIGINS ?? '*'
+}

packages/server/src/utils/index.ts

@@ -273,6 +273,7 @@ export const buildLangchain = async (
     question: string,
     chatHistory: IMessage[],
     chatId: string,
+    sessionId: string,
     chatflowid: string,
     appDataSource: DataSource,
     overrideConfig?: ICommonObject,
@@ -317,6 +318,7 @@ export const buildLangchain = async (
                 logger.debug(`[server]: Upserting ${reactFlowNode.data.label} (${reactFlowNode.data.id})`)
                 await newNodeInstance.vectorStoreMethods!['upsert']!.call(newNodeInstance, reactFlowNodeData, {
                     chatId,
+                    sessionId,
                     chatflowid,
                     chatHistory,
                     logger,
@@ -331,6 +333,7 @@ export const buildLangchain = async (
                 logger.debug(`[server]: Initializing ${reactFlowNode.data.label} (${reactFlowNode.data.id})`)
                 let outputResult = await newNodeInstance.init(reactFlowNodeData, question, {
                     chatId,
+                    sessionId,
                     chatflowid,
                     chatHistory,
                     logger,
@@ -607,28 +610,35 @@ export const resolveVariables = (
 export const replaceInputsWithConfig = (flowNodeData: INodeData, overrideConfig: ICommonObject) => {
     const types = 'inputs'
 
-    const getParamValues = (paramsObj: ICommonObject) => {
+    const getParamValues = (inputsObj: ICommonObject) => {
         for (const config in overrideConfig) {
             // If overrideConfig[key] is object
             if (overrideConfig[config] && typeof overrideConfig[config] === 'object') {
                 const nodeIds = Object.keys(overrideConfig[config])
                 if (nodeIds.includes(flowNodeData.id)) {
-                    paramsObj[config] = overrideConfig[config][flowNodeData.id]
+                    inputsObj[config] = overrideConfig[config][flowNodeData.id]
+                    continue
+                } else if (nodeIds.some((nodeId) => nodeId.includes(flowNodeData.name))) {
+                    /*
+                     * "systemMessagePrompt": {
+                     *   "chatPromptTemplate_0": "You are an assistant" <---- continue for loop if current node is chatPromptTemplate_1
+                     * }
+                     */
                     continue
                 }
             }
 
-            let paramValue = overrideConfig[config] ?? paramsObj[config]
+            let paramValue = overrideConfig[config] ?? inputsObj[config]
             // Check if boolean
             if (paramValue === 'true') paramValue = true
             else if (paramValue === 'false') paramValue = false
-            paramsObj[config] = paramValue
+            inputsObj[config] = paramValue
         }
     }
 
-    const paramsObj = flowNodeData[types] ?? {}
+    const inputsObj = flowNodeData[types] ?? {}
 
-    getParamValues(paramsObj)
+    getParamValues(inputsObj)
 
     return flowNodeData
 }
@@ -1079,6 +1089,10 @@ export const getAllValuesFromJson = (obj: any): any[] => {
     return values
 }
 
+/**
+ * Delete file & folder recursively
+ * @param {string} directory
+ */
 export const deleteFolderRecursive = (directory: string) => {
     if (fs.existsSync(directory)) {
         fs.readdir(directory, (error, files) => {
@@ -1102,3 +1116,60 @@ export const deleteFolderRecursive = (directory: string) => {
         })
     }
 }
+
+/**
+ * Get only essential flow data items for telemetry
+ * @param {IReactFlowNode[]} nodes
+ * @param {IReactFlowEdge[]} edges
+ */
+export const getTelemetryFlowObj = (nodes: IReactFlowNode[], edges: IReactFlowEdge[]) => {
+    const nodeData = nodes.map((node) => node.id)
+    const edgeData = edges.map((edge) => ({ source: edge.source, target: edge.target }))
+    return { nodes: nodeData, edges: edgeData }
+}
+
+/**
+ * Get user settings file
+ * TODO: move env variables to settings json file, easier configuration
+ */
+export const getUserSettingsFilePath = () => {
+    if (process.env.SECRETKEY_PATH) return path.join(process.env.SECRETKEY_PATH, 'settings.json')
+    const checkPaths = [path.join(getUserHome(), '.flowise', 'settings.json')]
+    for (const checkPath of checkPaths) {
+        if (fs.existsSync(checkPath)) {
+            return checkPath
+        }
+    }
+    return ''
+}
+
+/**
+ * Get app current version
+ */
+export const getAppVersion = async () => {
+    const getPackageJsonPath = (): string => {
+        const checkPaths = [
+            path.join(__dirname, '..', 'package.json'),
+            path.join(__dirname, '..', '..', 'package.json'),
+            path.join(__dirname, '..', '..', '..', 'package.json'),
+            path.join(__dirname, '..', '..', '..', '..', 'package.json'),
+            path.join(__dirname, '..', '..', '..', '..', '..', 'package.json')
+        ]
+        for (const checkPath of checkPaths) {
+            if (fs.existsSync(checkPath)) {
+                return checkPath
+            }
+        }
+        return ''
+    }
+
+    const packagejsonPath = getPackageJsonPath()
+    if (!packagejsonPath) return ''
+    try {
+        const content = await fs.promises.readFile(packagejsonPath, 'utf8')
+        const parsedContent = JSON.parse(content)
+        return parsedContent.version
+    } catch (error) {
+        return ''
+    }
+}

packages/server/src/utils/telemetry.ts

@@ -0,0 +1,52 @@
+import { v4 as uuidv4 } from 'uuid'
+import { PostHog } from 'posthog-node'
+import path from 'path'
+import fs from 'fs'
+import { getUserHome, getUserSettingsFilePath } from '.'
+
+export class Telemetry {
+    postHog?: PostHog
+
+    constructor() {
+        if (process.env.DISABLE_FLOWISE_TELEMETRY !== 'true') {
+            this.postHog = new PostHog('phc_jEDuFYnOnuXsws986TLWzuisbRjwFqTl9JL8tDMgqme')
+        } else {
+            this.postHog = undefined
+        }
+    }
+
+    async id(): Promise<string> {
+        try {
+            const settingsContent = await fs.promises.readFile(getUserSettingsFilePath(), 'utf8')
+            const settings = JSON.parse(settingsContent)
+            return settings.instanceId
+        } catch (error) {
+            const instanceId = uuidv4()
+            const settings = {
+                instanceId
+            }
+            const defaultLocation = process.env.SECRETKEY_PATH
+                ? path.join(process.env.SECRETKEY_PATH, 'settings.json')
+                : path.join(getUserHome(), '.flowise', 'settings.json')
+            await fs.promises.writeFile(defaultLocation, JSON.stringify(settings, null, 2))
+            return instanceId
+        }
+    }
+
+    async sendTelemetry(event: string, properties = {}): Promise<void> {
+        if (this.postHog) {
+            const distinctId = await this.id()
+            this.postHog.capture({
+                event,
+                distinctId,
+                properties
+            })
+        }
+    }
+
+    async flush(): Promise<void> {
+        if (this.postHog) {
+            await this.postHog.shutdownAsync()
+        }
+    }
+}