reorganize dirs for dockerize

api/server/index.js

@@ -0,0 +1,28 @@
+const express = require('express');
+const dbConnect = require('../models/dbConnect');
+const path = require('path');
+const cors = require('cors');
+const routes = require('./routes');
+const app = express();
+const port = process.env.PORT || 3050;
+const projectPath = path.join(__dirname, '..', '..');
+dbConnect().then(() => console.log('Connected to MongoDB'));
+
+app.use(cors());
+app.use(express.json());
+app.use(express.static(path.join(projectPath, 'public')));
+
+app.get('/', function (req, res) {
+  console.log(path.join(projectPath, 'public', 'index.html'));
+  res.sendFile(path.join(projectPath, 'public', 'index.html'));
+});
+
+app.use('/ask', routes.ask);
+app.use('/messages', routes.messages);
+app.use('/convos', routes.convos);
+app.use('/customGpts', routes.customGpts);
+app.use('/prompts', routes.prompts);
+
+app.listen(port, () => {
+  console.log(`Server listening at http://localhost:${port}`);
+});

api/server/routes/ask.js

@@ -0,0 +1,143 @@
+const express = require('express');
+const crypto = require('crypto');
+const router = express.Router();
+const askBing = require('./askBing');
+const {
+  titleConvo,
+  askClient,
+  browserClient,
+  customClient,
+  detectCode
+} = require('../../app/');
+const { saveMessage, deleteMessages, saveConvo } = require('../../models');
+const { handleError, sendMessage } = require('./handlers');
+
+router.use('/bing', askBing);
+
+router.post('/', async (req, res) => {
+  const { model, text, parentMessageId, conversationId, chatGptLabel, promptPrefix } =
+    req.body;
+  if (!text.trim().includes(' ') && text.length < 5) {
+    return handleError(res, 'Prompt empty or too short');
+  }
+
+  const userMessageId = crypto.randomUUID();
+  let userMessage = { id: userMessageId, sender: 'User', text };
+
+  console.log('ask log', {
+    model,
+    ...userMessage,
+    parentMessageId,
+    conversationId,
+    chatGptLabel,
+    promptPrefix
+  });
+
+  let client;
+
+  if (model === 'chatgpt') {
+    client = askClient;
+  } else if (model === 'chatgptCustom') {
+    client = customClient;
+  } else {
+    client = browserClient;
+  }
+
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  try {
+    let i = 0;
+    let tokens = '';
+    const progressCallback = async (partial) => {
+      if (i === 0 && typeof partial === 'object') {
+        userMessage.parentMessageId = parentMessageId ? parentMessageId : partial.id;
+        userMessage.conversationId = conversationId ? conversationId : partial.conversationId;
+        await saveMessage(userMessage);
+        sendMessage(res, { ...partial, initial: true });
+        i++;
+      }
+
+      if (typeof partial === 'object') {
+        sendMessage(res, { ...partial, message: true });
+      } else {
+        tokens += partial === text ? '' : partial;
+        if (tokens.includes('[DONE]')) {
+          tokens = tokens.replace('[DONE]', '');
+        }
+
+        // tokens = await detectCode(tokens);
+        sendMessage(res, { text: tokens, message: true, initial: i === 0 ? true : false });
+        i++;
+      }
+    };
+
+    let gptResponse = await client({
+      text,
+      progressCallback,
+      convo: {
+        parentMessageId,
+        conversationId
+      },
+      chatGptLabel,
+      promptPrefix
+    });
+
+    console.log('CLIENT RESPONSE', gptResponse);
+
+    if (!gptResponse.parentMessageId) {
+      gptResponse.text = gptResponse.response;
+      gptResponse.id = gptResponse.messageId;
+      gptResponse.parentMessageId = gptResponse.messageId;
+      userMessage.parentMessageId = parentMessageId ? parentMessageId : gptResponse.messageId;
+      userMessage.conversationId = conversationId
+        ? conversationId
+        : gptResponse.conversationId;
+      await saveMessage(userMessage);
+      delete gptResponse.response;
+    }
+
+    if (
+      (gptResponse.text.includes('2023') && !gptResponse.text.trim().includes(' ')) ||
+      gptResponse.text.toLowerCase().includes('no response') ||
+      gptResponse.text.toLowerCase().includes('no answer')
+    ) {
+      return handleError(res, 'Prompt empty or too short');
+    }
+
+    if (!parentMessageId) {
+      gptResponse.title = await titleConvo({
+        model,
+        message: text,
+        response: JSON.stringify(gptResponse.text)
+      });
+    }
+    gptResponse.sender = model === 'chatgptCustom' ? chatGptLabel : model;
+    gptResponse.final = true;
+    gptResponse.text = await detectCode(gptResponse.text);
+
+    if (chatGptLabel?.length > 0 && model === 'chatgptCustom') {
+      gptResponse.chatGptLabel = chatGptLabel;
+    }
+
+    if (promptPrefix?.length > 0 && model === 'chatgptCustom') {
+      gptResponse.promptPrefix = promptPrefix;
+    }
+
+    await saveMessage(gptResponse);
+    await saveConvo(gptResponse);
+    sendMessage(res, gptResponse);
+    res.end();
+  } catch (error) {
+    console.log(error);
+    await deleteMessages({ id: userMessageId });
+    handleError(res, error.message);
+  }
+});
+
+module.exports = router;

api/server/routes/askBing.js

@@ -0,0 +1,72 @@
+const express = require('express');
+const crypto = require('crypto');
+const router = express.Router();
+const { titleConvo, askBing } = require('../../app/');
+const { saveMessage, deleteMessages, saveConvo } = require('../../models');
+const { handleError, sendMessage } = require('./handlers');
+
+router.post('/', async (req, res) => {
+  const { model, text, ...convo } = req.body;
+  if (!text.trim().includes(' ') && text.length < 5) {
+    return handleError(res, 'Prompt empty or too short');
+  }
+
+  const userMessageId = crypto.randomUUID();
+  let userMessage = { id: userMessageId, sender: 'User', text };
+
+  console.log('ask log', { model, ...userMessage, ...convo });
+
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  try {
+    let tokens = '';
+    const progressCallback = async (partial) => {
+      tokens += partial === text ? '' : partial;
+      // tokens = appendCode(tokens);
+      sendMessage(res, { text: tokens, message: true });
+    };
+
+    let response = await askBing({
+      text,
+      progressCallback,
+      convo
+    });
+
+    console.log('CLIENT RESPONSE');
+    console.dir(response, { depth: null });
+
+    userMessage.conversationSignature =
+      convo.conversationSignature || response.conversationSignature;
+    userMessage.conversationId = convo.conversationId || response.conversationId;
+    userMessage.invocationId = response.invocationId;
+    await saveMessage(userMessage);
+
+    if (!convo.conversationSignature) {
+      response.title = await titleConvo(text, response.response, model);
+    }
+
+    response.text = response.response;
+    response.id = response.details.messageId;
+    response.suggestions =
+      response.details.suggestedResponses &&
+      response.details.suggestedResponses.map((s) => s.text);
+    response.sender = model;
+    response.final = true;
+    await saveMessage(response);
+    await saveConvo(response);
+    sendMessage(res, response);
+    res.end();
+  } catch (error) {
+    console.log(error);
+    await deleteMessages({ id: userMessageId });
+    handleError(res, error.message);
+  }
+});
+
+module.exports = router;

api/server/routes/convos.js

@@ -0,0 +1,38 @@
+const express = require('express');
+const router = express.Router();
+const { getConvos, deleteConvos, updateConvo } = require('../../models/Conversation');
+
+router.get('/', async (req, res) => {
+  const pageNumber = req.query.pageNumber || 1;
+  res.status(200).send(await getConvos(pageNumber));
+});
+
+router.post('/clear', async (req, res) => {
+  let filter = {};
+  const { conversationId } = req.body.arg;
+  if (conversationId) {
+    filter = { conversationId };
+  }
+
+  try {
+    const dbResponse = await deleteConvos(filter);
+    res.status(201).send(dbResponse);
+  } catch (error) {
+    console.error(error);
+    res.status(500).send(error);
+  }
+});
+
+router.post('/update', async (req, res) => {
+  const update = req.body.arg;
+
+  try {
+    const dbResponse = await updateConvo(update);
+    res.status(201).send(dbResponse);
+  } catch (error) {
+    console.error(error);
+    res.status(500).send(error);
+  }
+});
+
+module.exports = router;

api/server/routes/customGpts.js

@@ -0,0 +1,56 @@
+const express = require('express');
+const router = express.Router();
+const { getCustomGpts, updateCustomGpt, deleteCustomGpts } = require('../../models');
+
+router.get('/', async (req, res) => {
+  const models = (await getCustomGpts()).map(model => {
+    model = model.toObject();
+    model._id = model._id.toString();
+    return model;
+  });
+  // console.log(models);
+  res.status(200).send(models);
+});
+
+router.post('/delete/:_id', async (req, res) => {
+  const { _id } = req.params;
+  let filter = {};
+
+  if (_id) {
+    filter = { _id };
+  }
+
+  try {
+    const dbResponse = await deleteCustomGpts(filter);
+    res.status(201).send(dbResponse);
+  } catch (error) {
+    console.error(error);
+    res.status(500).send(error);
+  }
+});
+
+// router.post('/create', async (req, res) => {
+//   const payload = req.body.arg;
+
+//   try {
+//     const dbResponse = await createCustomGpt(payload);
+//     res.status(201).send(dbResponse);
+//   } catch (error) {
+//     console.error(error);
+//     res.status(500).send(error);
+//   }
+// });
+
+router.post('/', async (req, res) => {
+  const update = req.body.arg;
+
+  try {
+    const dbResponse = await updateCustomGpt(update);
+    res.status(201).send(dbResponse);
+  } catch (error) {
+    console.error(error);
+    res.status(500).send(error);
+  }
+});
+
+module.exports = router;

api/server/routes/handlers.js

@@ -0,0 +1,13 @@
+const handleError = (res, errorMessage) => {
+  res.status(500).write(`event: error\ndata: ${errorMessage}`);
+  res.end();
+};
+
+const sendMessage = (res, message) => {
+  if (message.length === 0) {
+    return;
+  }
+  res.write(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
+};
+
+module.exports = { handleError, sendMessage };

api/server/routes/index.js

@@ -0,0 +1,7 @@
+const ask = require('./ask');
+const messages = require('./messages');
+const convos = require('./convos');
+const customGpts = require('./customGpts');
+const prompts = require('./prompts');
+
+module.exports = { ask, messages, convos, customGpts, prompts };

api/server/routes/messages.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const router = express.Router();
+const { getMessages } = require('../../models/Message');
+
+router.get('/:conversationId', async (req, res) => {
+  const { conversationId } = req.params;
+  res.status(200).send(await getMessages({ conversationId }));
+});
+
+module.exports = router;

api/server/routes/prompts.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const { savePrompt, getPrompts, deletePrompts } = require('../../models/Prompt');
+
+router.get('/', async (req, res) => {
+  let filter = {};
+  // const { search } = req.body.arg;
+  // if (!!search) {
+  //   filter = { conversationId };
+  // }
+  res.status(200).send(await getPrompts(filter));
+});
+
+module.exports = router;