main.js

require('./runtime');

const { create_room_invite, encrypt_sealed_box, decrypt_sealed_box } = require('./utils');
const {
  send_message,
  create_swarm,
  end_swarm,
  share_file_info,
  close_all_connections,
  idle,
  send_voice_channel_status,
  send_typing_status,
  send_sdp,
  send_dm_message,
  send_dm_file,
  send_feed_message,
  download_file,
  Nodes
} = require('./swarm');
const { Hugin } = require('./account');
const { Bridge } = require('./rpc');
const { new_beam, send_beam_message } = require('./beam');
const { IPC } = BareKit;

const rpc = new Bridge(IPC);
rpc.on('data', (data) => response(data));

const onrequest = async (p) => {
  switch (p.type) {
    case 'log':
      break;
    case 'get_sealed_box':
      console.log('🎁 Returning sealed box from backend')
      const box = encrypt_sealed_box(p.data.messageKey, p.data.data);
      return { box };
    case 'decrypt_sealed_box':
      console.log('🎁 Decrypting sealed box from backend')
      const plaintext = decrypt_sealed_box(p.data);
      return { plaintext };
    case 'push_registration':
      const pushRegistered = await Nodes.register(p.data);
      return { sent: pushRegistered };
    case 'init_bare':
      initBareMain(p.user);
      break;
    case 'update_bare_user':
      updateBareUser(p.user);
      break;
    case 'new_beam':
      await new_beam(p.key, p.huginAddress, p.send);
      break;
    case 'beam_message':
      send_dm_message(p.address, p.message);
      break;
    case 'new_swarm':
      await newSwarm(p.hashkey, p.key, p.admin, p.beam, p.chat);
      break;
    case 'end_swarm':
      return await endSwarm(p.key);
    case 'send_room_msg':
      const message = sendRoomMessage(p.hash, p.message, p.key, p.reply, p.tip);
      return message;
    case 'send_feed_msg':
      const feed_message = await send_feed_message(p.message, p.reply, p.tip);
      return feed_message;
    case 'send_node_msg':
      const sent = await Nodes.message(p.payload, p.hash, p.viewtag, p.kind);
      return {sent};
    case 'sync_from_node':
      const resp = await Nodes.sync(p.request)
      return {resp, background: Hugin.background}
    case 'connect_to_node':
      Nodes.connect(p.address, p.pub)
      return
    case 'group_random_key':
      const keys = create_room_invite();
      return { keys };
    case 'begin_send_file':
      sendFileInfo(p.json_file_data);
      break;
    case 'send_dm_file':
      send_dm_file(p.address, p.file);
      break;
    case 'request_download':
      request_download(p.file);
      break;
    case 'group_download':
      download_file(p.file);
      break;
    case 'save_to_downloads':
      const saveResult = await Storage.save_to_downloads(p.hash, p.fileName, p.topic);
      if (saveResult.success) {
        Hugin.send('file-saved-to-downloads', { hash: p.hash, filePath: saveResult.filePath, fileName: p.fileName });
      } else {
        Hugin.send('error-message', { message: saveResult.error || 'Failed to save file' });
      }
      return saveResult;

    case 'keep_alive':
      break;
    case 'idle_status':
      Hugin.sleep(p.mode, p.background);
      idle(p.background, p.force);
      break;
    case 'close_connections':
      close_all_connections();
      break;
    case 'voice_status':
      send_voice_channel_status(p.status.voice, p.status, p.update);
      break;
    case 'typing':
      send_typing_status(p.typing, p.key);
      break;
    case 'send_sdp':
      send_sdp(p.data);
      break;
    default:
      break;
  }
  return;
};

async function response(request) {
  try {
    const send = await onrequest(request);
    if (send === undefined) return;
    send.id = request.id;
    rpc.send(request.type, send);
  } catch (e) {
    try {
      console.error('Bare worklet request failed:', request?.type, e?.stack ?? e);
      if (request?.id !== undefined) {
        rpc.send(request.type, {
          id: request.id,
          error: (e && typeof e === 'object' && 'message' in e) ? e.message : String(e),
        });
      }
    } catch (_) {
      // Never throw from the worklet request handler.
    }
  }
}

// Function implementations
const initBareMain = async (user) => {
  Hugin.init(user, rpc);
};

const updateBareUser = (user) => {
  Hugin.update(user);
};

const newSwarm = async (hashkey, key, admin, beam, chat) => {
  if (Hugin.rooms.some((a) => a.key === key)) return;
  Hugin.rooms.push({ key, topic: null, admin });
  try {
    const topic = await create_swarm(hashkey, key, beam, chat);
    const entry = Hugin.rooms.find((a) => a.key === key);
    if (entry) entry.topic = topic ?? null;
  } catch (e) {
    Hugin.rooms = Hugin.rooms.filter((a) => a.key !== key);
    return;
  }
};

const endSwarm = async (key) => {
  const swarm = getRoom(key);
  if (!swarm) return;
  const rooms = Hugin.rooms.filter((a) => a.key !== key);
  Hugin.rooms = rooms;
  end_swarm(swarm.topic);
};

const sendRoomMessage = (hash, message, key, reply, tip) => {
  const swarm = getRoom(key);
  if (!swarm) return { type: 'Error' };
  return send_message(hash, message, swarm.topic, reply, key, tip);
};

const getRoom = (key) => {
  return Hugin.rooms.find((a) => a.key === key);
};

const sendFileInfo = (json_file_data) => {
  const file_data = JSON.parse(json_file_data);
  const room = getRoom(file_data.key);
  if (!room) {
    return;
  }

  share_file_info(file_data, room.topic);
};