Flowise

1
import { Command, Flags } from '@oclif/core'
2
import path from 'path'
3
import * as Server from '../index'
4
import * as DataSource from '../DataSource'
5
import dotenv from 'dotenv'
6
import logger from '../utils/logger'
7

8
dotenv.config({ path: path.join(__dirname, '..', '..', '.env'), override: true })
9

10
enum EXIT_CODE {
11
    SUCCESS = 0,
12
    FAILED = 1
13
}
14
let processExitCode = EXIT_CODE.SUCCESS
15

16
export default class Start extends Command {
17
    static args = []
18
    static flags = {
19
        FLOWISE_USERNAME: Flags.string(),
20
        FLOWISE_PASSWORD: Flags.string(),
21
        FLOWISE_FILE_SIZE_LIMIT: Flags.string(),
22
        PORT: Flags.string(),
23
        CORS_ORIGINS: Flags.string(),
24
        IFRAME_ORIGINS: Flags.string(),
25
        DEBUG: Flags.string(),
26
        BLOB_STORAGE_PATH: Flags.string(),
27
        APIKEY_PATH: Flags.string(),
28
        SECRETKEY_PATH: Flags.string(),
29
        FLOWISE_SECRETKEY_OVERWRITE: Flags.string(),
30
        LOG_PATH: Flags.string(),
31
        LOG_LEVEL: Flags.string(),
32
        TOOL_FUNCTION_BUILTIN_DEP: Flags.string(),
33
        TOOL_FUNCTION_EXTERNAL_DEP: Flags.string(),
34
        NUMBER_OF_PROXIES: Flags.string(),
35
        DATABASE_TYPE: Flags.string(),
36
        DATABASE_PATH: Flags.string(),
37
        DATABASE_PORT: Flags.string(),
38
        DATABASE_HOST: Flags.string(),
39
        DATABASE_NAME: Flags.string(),
40
        DATABASE_USER: Flags.string(),
41
        DATABASE_PASSWORD: Flags.string(),
42
        DATABASE_SSL: Flags.string(),
43
        DATABASE_SSL_KEY_BASE64: Flags.string(),
44
        LANGCHAIN_TRACING_V2: Flags.string(),
45
        LANGCHAIN_ENDPOINT: Flags.string(),
46
        LANGCHAIN_API_KEY: Flags.string(),
47
        LANGCHAIN_PROJECT: Flags.string(),
48
        DISABLE_FLOWISE_TELEMETRY: Flags.string(),
49
        MODEL_LIST_CONFIG_JSON: Flags.string(),
50
        STORAGE_TYPE: Flags.string(),
51
        S3_STORAGE_BUCKET_NAME: Flags.string(),
52
        S3_STORAGE_ACCESS_KEY_ID: Flags.string(),
53
        S3_STORAGE_SECRET_ACCESS_KEY: Flags.string(),
54
        S3_STORAGE_REGION: Flags.string()
55
    }
56

57
    async stopProcess() {
58
        logger.info('Shutting down Flowise...')
59
        try {
60
            // Shut down the app after timeout if it ever stuck removing pools
61
            setTimeout(() => {
62
                logger.info('Flowise was forced to shut down after 30 secs')
63
                process.exit(processExitCode)
64
            }, 30000)
65

66
            // Removing pools
67
            const serverApp = Server.getInstance()
68
            if (serverApp) await serverApp.stopApp()
69
        } catch (error) {
70
            logger.error('There was an error shutting down Flowise...', error)
71
        }
72
        process.exit(processExitCode)
73
    }
74

75
    async run(): Promise<void> {
76
        process.on('SIGTERM', this.stopProcess)
77
        process.on('SIGINT', this.stopProcess)
78

79
        // Prevent throw new Error from crashing the app
80
        // TODO: Get rid of this and send proper error message to ui
81
        process.on('uncaughtException', (err) => {
82
            logger.error('uncaughtException: ', err)
83
        })
84

85
        process.on('unhandledRejection', (err) => {
86
            logger.error('unhandledRejection: ', err)
87
        })
88

89
        const { flags } = await this.parse(Start)
90

91
        if (flags.PORT) process.env.PORT = flags.PORT
92
        if (flags.CORS_ORIGINS) process.env.CORS_ORIGINS = flags.CORS_ORIGINS
93
        if (flags.IFRAME_ORIGINS) process.env.IFRAME_ORIGINS = flags.IFRAME_ORIGINS
94
        if (flags.DEBUG) process.env.DEBUG = flags.DEBUG
95
        if (flags.NUMBER_OF_PROXIES) process.env.NUMBER_OF_PROXIES = flags.NUMBER_OF_PROXIES
96

97
        // Authorization
98
        if (flags.FLOWISE_USERNAME) process.env.FLOWISE_USERNAME = flags.FLOWISE_USERNAME
99
        if (flags.FLOWISE_PASSWORD) process.env.FLOWISE_PASSWORD = flags.FLOWISE_PASSWORD
100
        if (flags.APIKEY_PATH) process.env.APIKEY_PATH = flags.APIKEY_PATH
101

102
        // API Configuration
103
        if (flags.FLOWISE_FILE_SIZE_LIMIT) process.env.FLOWISE_FILE_SIZE_LIMIT = flags.FLOWISE_FILE_SIZE_LIMIT
104

105
        // Credentials
106
        if (flags.SECRETKEY_PATH) process.env.SECRETKEY_PATH = flags.SECRETKEY_PATH
107
        if (flags.FLOWISE_SECRETKEY_OVERWRITE) process.env.FLOWISE_SECRETKEY_OVERWRITE = flags.FLOWISE_SECRETKEY_OVERWRITE
108

109
        // Logs
110
        if (flags.LOG_PATH) process.env.LOG_PATH = flags.LOG_PATH
111
        if (flags.LOG_LEVEL) process.env.LOG_LEVEL = flags.LOG_LEVEL
112

113
        // Tool functions
114
        if (flags.TOOL_FUNCTION_BUILTIN_DEP) process.env.TOOL_FUNCTION_BUILTIN_DEP = flags.TOOL_FUNCTION_BUILTIN_DEP
115
        if (flags.TOOL_FUNCTION_EXTERNAL_DEP) process.env.TOOL_FUNCTION_EXTERNAL_DEP = flags.TOOL_FUNCTION_EXTERNAL_DEP
116

117
        // Database config
118
        if (flags.DATABASE_TYPE) process.env.DATABASE_TYPE = flags.DATABASE_TYPE
119
        if (flags.DATABASE_PATH) process.env.DATABASE_PATH = flags.DATABASE_PATH
120
        if (flags.DATABASE_PORT) process.env.DATABASE_PORT = flags.DATABASE_PORT
121
        if (flags.DATABASE_HOST) process.env.DATABASE_HOST = flags.DATABASE_HOST
122
        if (flags.DATABASE_NAME) process.env.DATABASE_NAME = flags.DATABASE_NAME
123
        if (flags.DATABASE_USER) process.env.DATABASE_USER = flags.DATABASE_USER
124
        if (flags.DATABASE_PASSWORD) process.env.DATABASE_PASSWORD = flags.DATABASE_PASSWORD
125
        if (flags.DATABASE_SSL) process.env.DATABASE_SSL = flags.DATABASE_SSL
126
        if (flags.DATABASE_SSL_KEY_BASE64) process.env.DATABASE_SSL_KEY_BASE64 = flags.DATABASE_SSL_KEY_BASE64
127

128
        // Langsmith tracing
129
        if (flags.LANGCHAIN_TRACING_V2) process.env.LANGCHAIN_TRACING_V2 = flags.LANGCHAIN_TRACING_V2
130
        if (flags.LANGCHAIN_ENDPOINT) process.env.LANGCHAIN_ENDPOINT = flags.LANGCHAIN_ENDPOINT
131
        if (flags.LANGCHAIN_API_KEY) process.env.LANGCHAIN_API_KEY = flags.LANGCHAIN_API_KEY
132
        if (flags.LANGCHAIN_PROJECT) process.env.LANGCHAIN_PROJECT = flags.LANGCHAIN_PROJECT
133

134
        // Telemetry
135
        if (flags.DISABLE_FLOWISE_TELEMETRY) process.env.DISABLE_FLOWISE_TELEMETRY = flags.DISABLE_FLOWISE_TELEMETRY
136

137
        // Disable langchain warnings
138
        process.env.LANGCHAIN_SUPPRESS_MIGRATION_WARNINGS = 'true'
139

140
        // Model list config
141
        if (flags.MODEL_LIST_CONFIG_JSON) process.env.MODEL_LIST_CONFIG_JSON = flags.MODEL_LIST_CONFIG_JSON
142

143
        // Storage
144
        if (flags.STORAGE_TYPE) process.env.STORAGE_TYPE = flags.STORAGE_TYPE
145
        if (flags.BLOB_STORAGE_PATH) process.env.BLOB_STORAGE_PATH = flags.BLOB_STORAGE_PATH
146
        if (flags.S3_STORAGE_BUCKET_NAME) process.env.S3_STORAGE_BUCKET_NAME = flags.S3_STORAGE_BUCKET_NAME
147
        if (flags.S3_STORAGE_ACCESS_KEY_ID) process.env.S3_STORAGE_ACCESS_KEY_ID = flags.S3_STORAGE_ACCESS_KEY_ID
148
        if (flags.S3_STORAGE_SECRET_ACCESS_KEY) process.env.S3_STORAGE_SECRET_ACCESS_KEY = flags.S3_STORAGE_SECRET_ACCESS_KEY
149
        if (flags.S3_STORAGE_REGION) process.env.S3_STORAGE_REGION = flags.S3_STORAGE_REGION
150

151
        await (async () => {
152
            try {
153
                logger.info('Starting Flowise...')
154
                await DataSource.init()
155
                await Server.start()
156
            } catch (error) {
157
                logger.error('There was an error starting Flowise...', error)
158
                processExitCode = EXIT_CODE.FAILED
159
                // @ts-ignore
160
                process.emit('SIGINT')
161
            }
162
        })()
163
    }
164
}
165