gpthouse-embed 3.0.5

package/dist/window.d.ts

@@ -0,0 +1,30 @@
+import { observersConfigType } from './components/Bot';
+import { BubbleTheme } from './features/bubble/types';
+type BotProps = {
+    chatflowid: string;
+    apiHost?: string;
+    onRequest?: (request: RequestInit) => Promise<void>;
+    chatflowConfig?: Record<string, unknown>;
+    observersConfig?: observersConfigType;
+    theme?: BubbleTheme;
+};
+export declare const initFull: (props: BotProps & {
+    id?: string;
+}) => void;
+export declare const init: (props: BotProps) => void;
+export declare const destroy: () => void;
+type Chatbot = {
+    initFull: typeof initFull;
+    init: typeof init;
+    destroy: typeof destroy;
+};
+export declare const parseChatbot: () => {
+    initFull: (props: BotProps & {
+        id?: string;
+    }) => void;
+    init: (props: BotProps) => void;
+    destroy: () => void;
+};
+export declare const injectChatbotInWindow: (bot: Chatbot) => void;
+export {};
+//# sourceMappingURL=window.d.ts.map

package/dist/window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../src/window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,KAAK,QAAQ,GAAG;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,CAAC;AAIF,eAAO,MAAM,QAAQ,UAAW,QAAQ,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,SAWzD,CAAC;AAEF,eAAO,MAAM,IAAI,UAAW,QAAQ,SAMnC,CAAC;AAEF,eAAO,MAAM,OAAO,YAEnB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,OAAO,EAAE,OAAO,OAAO,CAAC;CACzB,CAAC;AAQF,eAAO,MAAM,YAAY;sBArCO,QAAQ,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE;kBAa9B,QAAQ;;CA4BlC,CAAC;AAEH,eAAO,MAAM,qBAAqB,QAAS,OAAO,SAGjD,CAAC"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "gpthouse-embed",
+  "version": "3.0.5",
+  "description": "Javascript library to display gpthouse chatbot on your website",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "dev": "cross-env NODE_ENV=development rollup --watch --config rollup.config.js",
+    "build": "cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "lint-fix": "eslint --fix \"src/**/*.ts*\"",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,md,mdx}\"",
+    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,md,mdx}\"",
+    "prepare": "husky install",
+    "start": "node server.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@babel/core": "^7.22.1",
+    "@microsoft/fetch-event-source": "^2.0.1",
+    "@ts-stack/markdown": "^1.4.0",
+    "axios": "^1.7.7",
+    "cors": "^2.8.5",
+    "cross-env": "^7.0.3",
+    "device-detector-js": "^3.0.3",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.1",
+    "form-data": "^4.0.1",
+    "lodash": "^4.17.21",
+    "multer": "^1.4.5-lts.1",
+    "node-fetch": "^3.3.2",
+    "prettier": "^3.1.0",
+    "solid-element": "1.7.0",
+    "solid-js": "1.7.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "7.21.4",
+    "@rollup/plugin-babel": "6.0.3",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "15.0.1",
+    "@rollup/plugin-terser": "0.4.0",
+    "@rollup/plugin-typescript": "11.0.0",
+    "@tailwindcss/typography": "^0.5.10",
+    "@types/lodash": "^4.14.195",
+    "@types/node": "18.15.11",
+    "@types/uuid": "^8.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "autoprefixer": "10.4.14",
+    "babel-plugin-lodash": "^3.3.4",
+    "babel-preset-solid": "1.7.1",
+    "eslint": "^8.24.0",
+    "eslint-config-next": "13.2.4",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "eslint-plugin-react": "^7.26.1",
+    "eslint-plugin-solid": "0.12.0",
+    "husky": "^8.0.0",
+    "postcss": "8.4.21",
+    "react": "18.2.0",
+    "rollup": "3.23.0",
+    "rollup-plugin-livereload": "2.0.5",
+    "rollup-plugin-postcss": "4.0.2",
+    "rollup-plugin-serve": "2.0.2",
+    "rollup-plugin-typescript-paths": "1.4.0",
+    "rollup-plugin-uglify": "^6.0.4",
+    "tailwindcss": "3.3.1",
+    "typescript": "5.0.3",
+    "uuid": "^9.0.1"
+  }
+}

package/public/index.html

@@ -0,0 +1,37 @@
+<!--
+  NOTE: This .html file (and public folder) is optional and can be safely deleted.
+  It serves only as a demo/test page.
+  
+  The chatbot can be embedded directly on any allowed domain using the embed script that
+  is generated when starting the server.
+-->
+
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>GptHouse Chatbot Widget</title>
+</head>
+
+<body>
+    <div id="root"></div>
+    <script type="module">
+        import Chatbot from './web.js'
+        
+        // Example initialization:
+        // If your .env contains:
+        // agent1=xyz789-uvw456,https://example.com
+        // support=abc123-def456,https://example.com
+        // salesbot=ghi123-jkl456,https://example.com
+        //
+        // Then use the environment variable name as chatflowid:
+        Chatbot.init({
+            chatflowid: 'agent1',    // or 'support', 'salesbot', etc.
+            apiHost: window.location.origin
+        })
+    </script>
+</body>
+
+</html>

package/server.js

@@ -0,0 +1,394 @@
+Error.stackTraceLimit = 0;
+
+import express from 'express';
+import cors from 'cors';
+import fetch from 'node-fetch';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import axios from 'axios';
+import multer from 'multer';
+import FormData from 'form-data';
+import { generateEmbedScript } from './src/utils/embedScript.js';
+
+dotenv.config();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const API_HOST = process.env.API_HOST;
+const GPTHOUSE_API_KEY = process.env.GPTHOUSE_API_KEY;
+
+if (!API_HOST) {
+  console.error('API_HOST is not set in environment variables');
+  process.exit(1);
+}
+
+if (!GPTHOUSE_API_KEY) {
+  console.error('GPTHOUSE_API_KEY is not set in environment variables');
+  process.exit(1);
+}
+
+const parseChatflows = () => {
+  try {
+    const chatflows = new Map();
+
+    // Get all environment variables that don't start with special prefixes
+    const chatflowVars = Object.entries(process.env).filter(([key]) => {
+      return (
+        !key.startsWith('_') &&
+        !key.startsWith('npm_') &&
+        !key.startsWith('yarn_') &&
+        !key.startsWith('VSCODE_') &&
+        key !== 'API_HOST' &&
+        key !== 'GPTHOUSE_API_KEY' &&
+        key !== 'PORT' &&
+        key !== 'HOST' &&
+        key !== 'BASE_URL' &&
+        key !== 'NODE_ENV'
+      );
+    });
+
+    if (chatflowVars.length === 0) {
+      console.error('No chatflow configurations found in environment variables');
+      process.exit(1);
+    }
+
+    const defaultDomains = process.env.NODE_ENV === 'production' ? [] : ['http://localhost:5678'];
+
+    for (const [identifier, value] of chatflowVars) {
+      const parts = value.split(',').map((s) => s.trim());
+      const chatflowId = parts[0];
+      const configuredDomains = parts.length > 1 ? parts.slice(1) : [];
+
+      const domains = [...new Set([...defaultDomains, ...configuredDomains])];
+
+      if (!chatflowId) {
+        console.error(`Missing chatflow ID for ${identifier}`);
+        continue;
+      }
+
+      if (domains.includes('*')) {
+        console.error(`\x1b[31mError: Wildcard (*) domains are not allowed in ${identifier}. This flow will not be accessible.\x1b[0m`);
+        continue;
+      }
+
+      chatflows.set(identifier, { chatflowId, domains });
+    }
+
+    if (chatflows.size === 0) {
+      console.error('No valid chatflow configurations found');
+      process.exit(1);
+    }
+
+    return chatflows;
+  } catch (error) {
+    console.error('Failed to parse chatflow configurations:', error);
+    process.exit(1);
+  }
+};
+
+const chatflows = parseChatflows();
+
+const getChatflowDetails = (identifier) => {
+  let chatflow = chatflows.get(identifier);
+
+  if (!chatflow) {
+    const lowerIdentifier = identifier.toLowerCase();
+    for (const [key, value] of chatflows.entries()) {
+      if (key.toLowerCase() === lowerIdentifier) {
+        chatflow = value;
+        break;
+      }
+    }
+  }
+
+  if (!chatflow) {
+    throw new Error(`Chatflow not found: ${identifier}`);
+  }
+  return chatflow;
+};
+
+const isValidUUID = (str) => {
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidPattern.test(str);
+};
+
+const isValidChatflowConfig = (value) => {
+  if (!value) return false;
+  const parts = value.split(',').map((s) => s.trim());
+  return isValidUUID(parts[0]);
+};
+
+console.info('\x1b[36m%s\x1b[0m', 'Configured chatflows:');
+chatflows.forEach((config, identifier) => {
+  if (isValidChatflowConfig(config.chatflowId)) {
+    console.info('\x1b[36m%s\x1b[0m', `  ${identifier}: ${config.chatflowId} (${config.domains.join(', ')})`);
+  }
+});
+
+const isValidDomain = (origin, domains) => {
+  if (!origin) return true;
+  return domains.includes(origin);
+};
+
+const app = express();
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ limit: '50mb', extended: true }));
+
+app.use(
+  cors({
+    origin: true,
+    credentials: true,
+    methods: ['GET', 'POST', 'PUT', 'OPTIONS'],
+    allowedHeaders: ['*'],
+  }),
+);
+
+app.get('/', (_, res) => {
+  res.sendFile(path.join(__dirname, 'public', 'index.html'));
+});
+
+app.get('/web.js', (req, res) => {
+  const origin = req.headers.origin;
+
+  const allAllowedDomains = Array.from(chatflows.values()).flatMap((config) => config.domains);
+
+  if (!isValidDomain(origin, allAllowedDomains)) {
+    return res.status(403).send('Access Denied');
+  }
+
+  res.set({
+    'Content-Type': 'application/javascript',
+    'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
+    Pragma: 'no-cache',
+    Expires: '0',
+  });
+  res.sendFile(path.join(__dirname, 'dist', 'web.js'));
+});
+
+const validateApiKey = (req, res, next) => {
+  if (req.path === '/web.js' || req.path === '/' || req.method === 'OPTIONS') {
+    return next();
+  }
+
+  if (req.path.includes('/get-upload-file')) {
+    return next();
+  }
+
+  let identifier;
+  const pathParts = req.path.split('/').filter(Boolean);
+
+  if (pathParts.length >= 3) {
+    identifier = pathParts[3];
+  } else {
+    identifier = req.query.chatflowId?.split('/')[0];
+  }
+
+  if (!identifier) {
+    return res.status(400).json({ error: 'Bad Request' });
+  }
+
+  let chatflow;
+  try {
+    chatflow = getChatflowDetails(identifier);
+    req.chatflow = chatflow;
+  } catch (error) {
+    return res.status(404).json({ error: 'Not Found' });
+  }
+
+  const origin = req.headers.origin;
+  const userAgent = req.headers['user-agent'];
+  const acceptLanguage = req.headers['accept-language'];
+  const accept = req.headers['accept'];
+  const secFetchMode = req.headers['sec-fetch-mode'];
+  const secFetchSite = req.headers['sec-fetch-site'];
+
+  if (
+    userAgent &&
+    acceptLanguage &&
+    accept &&
+    secFetchMode === 'cors' &&
+    secFetchSite &&
+    ['same-origin', 'same-site', 'cross-site'].includes(secFetchSite)
+  ) {
+    if (isValidDomain(origin, chatflow.domains)) {
+      return next();
+    }
+  }
+
+  const authHeader = req.headers.authorization;
+  if (authHeader && authHeader.startsWith('Bearer ') && authHeader.split(' ')[1] === GPTHOUSE_API_KEY) {
+    return next();
+  }
+
+  return res.status(401).json({ error: 'Unauthorized' });
+};
+
+app.use(validateApiKey);
+
+const proxyEndpoints = {
+  prediction: {
+    method: 'POST',
+    path: '/api/v1/prediction/:identifier',
+    target: '/api/v1/prediction',
+  },
+  config: {
+    method: 'GET',
+    path: '/api/v1/public-chatbotConfig/:identifier',
+    target: '/api/v1/public-chatbotConfig',
+  },
+  streaming: {
+    method: 'GET',
+    path: '/api/v1/chatflows-streaming/:identifier',
+    target: '/api/v1/chatflows-streaming',
+  },
+  files: {
+    method: 'GET',
+    path: '/api/v1/get-upload-file',
+    target: '/api/v1/get-upload-file',
+  },
+};
+
+const handleProxy = async (req, res, targetPath) => {
+  try {
+    let identifier = req.query.chatflowId?.split('/')[0] || req.path.split('/').pop() || null;
+
+    if (!identifier) {
+      return res.status(400).json({ error: 'Bad Request' });
+    }
+
+    const chatflow = getChatflowDetails(identifier);
+    if (!chatflow) {
+      return res.status(404).json({ error: 'Not Found' });
+    }
+
+    if (req.query.chatId && req.query.fileName) {
+      const url = `${API_HOST}${targetPath}?chatflowId=${chatflow.chatflowId}&chatId=${req.query.chatId}&fileName=${req.query.fileName}`;
+
+      const response = await fetch(url, {
+        method: req.method,
+        headers: {
+          Authorization: `Bearer ${GPTHOUSE_API_KEY}`,
+        },
+      });
+
+      if (!response.ok) {
+        console.error(`File proxy error: ${response.status} ${response.statusText}`);
+        return res.status(response.status).json({ error: `File proxy error: ${response.statusText}` });
+      }
+
+      const contentType = response.headers.get('content-type');
+      if (contentType) {
+        res.setHeader('Content-Type', contentType);
+      }
+
+      return response.body.pipe(res);
+    }
+
+    let finalPath = `${targetPath}/${chatflow.chatflowId}`;
+    const url = `${API_HOST}${finalPath}`;
+
+    const response = await fetch(url, {
+      method: req.method,
+      headers: {
+        ...(req.method !== 'GET' && { 'Content-Type': 'application/json' }),
+        Authorization: `Bearer ${GPTHOUSE_API_KEY}`,
+      },
+      body: req.method !== 'GET' ? JSON.stringify(req.body) : undefined,
+    });
+
+    if (!response.ok) {
+      console.error(`Proxy error: ${response.status} ${response.statusText}`);
+      return res.status(response.status).json({ error: `Proxy error: ${response.statusText}` });
+    }
+
+    const contentType = response.headers.get('content-type');
+
+    if (contentType?.includes('image/') || contentType?.includes('audio/') || contentType?.includes('application/octet-stream')) {
+      res.setHeader('Content-Type', contentType);
+      return response.body.pipe(res);
+    }
+
+    if (contentType?.includes('text/event-stream')) {
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+      return response.body.pipe(res);
+    }
+
+    if (contentType?.includes('application/json')) {
+      const data = await response.json();
+      return res.json(data);
+    }
+
+    return response.body.pipe(res);
+  } catch (error) {
+    console.error('Proxy error:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+Object.values(proxyEndpoints).forEach(({ method, path, target }) => {
+  app[method.toLowerCase()](path, (req, res) => {
+    return handleProxy(req, res, target);
+  });
+});
+
+const storage = multer.memoryStorage();
+const upload = multer({ storage: storage });
+
+app.post('/api/v1/attachments/:identifier/:chatId', upload.array('files'), async (req, res) => {
+  try {
+    const chatId = req.params.chatId;
+    if (!chatId) {
+      return res.status(400).json({ error: 'Bad Request' });
+    }
+
+    if (!req.files || req.files.length === 0) {
+      return res.status(400).json({ error: 'Bad Request' });
+    }
+
+    const form = new FormData();
+    req.files.forEach((file) => {
+      form.append('files', file.buffer, {
+        filename: file.originalname,
+        contentType: file.mimetype,
+      });
+    });
+
+    const chatflow = req.chatflow;
+    const targetUrl = `${API_HOST}/api/v1/attachments/${chatflow.chatflowId}/${chatId}`;
+
+    const response = await axios.post(targetUrl, form, {
+      headers: {
+        ...form.getHeaders(),
+        Authorization: `Bearer ${GPTHOUSE_API_KEY}`,
+      },
+    });
+
+    res.json(response.data);
+  } catch (error) {
+    console.error('Attachment upload error:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+});
+
+app.use((_req, res) => {
+  res.status(404).json({ error: 'Not Found' });
+});
+
+const PORT = process.env.PORT || 3001;
+const HOST = process.env.HOST || '0.0.0.0';
+
+const server = app.listen(PORT, HOST, () => {
+  const addr = server.address();
+  if (!addr || typeof addr === 'string') return;
+
+  const baseUrl =
+    process.env.BASE_URL || process.env.NODE_ENV === 'production'
+      ? `https://${process.env.HOST || 'localhost'}`
+      : `http://${HOST === '0.0.0.0' ? 'localhost' : HOST}:${addr.port}`;
+
+  generateEmbedScript(baseUrl);
+});