Very simple roblox file proxy. Read Write ListDirectory

FileIOModule.lua

local HttpService = game:GetService("HttpService")

local BASE_URL = "http://localhost:3090/"

local FileService = {}

function to_base64(data)
	local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
	return ((data:gsub('.', function(x) 
		local r,b='',x:byte()
		for i=8,1,-1 do r=r..(b%2^i-b%2^(i-1)>0 and '1' or '0') end
		return r;
	end)..'0000'):gsub('%d%d%d?%d?%d?%d?', function(x)
		if (#x < 6) then return '' end
		local c=0
		for i=1,6 do c=c+(x:sub(i,i)=='1' and 2^(6-i) or 0) end
		return b:sub(c+1,c+1)
	end)..({ '', '==', '=' })[#data%3+1])
end

function from_base64(data)
	local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
	data = string.gsub(data, '[^'..b..'=]', '')
	return (data:gsub('.', function(x)
		if (x == '=') then return '' end
		local r,f='',(b:find(x)-1)
		for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
		return r;
	end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
		if (#x ~= 8) then return '' end
		local c=0
		for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
		return string.char(c)
	end))
end

function FileService:ListDirectory(directoryPath)
	local success, response = pcall(function()
 
		return HttpService:GetAsync(BASE_URL .. "?operation=list&path=" .. directoryPath)
	end)
	if success then
		local struct = HttpService:JSONDecode(response)
		local dir = {}
		for key,value in struct do
			local res = from_base64(value)	
			table.insert(dir, res)
		end
		
		return dir
	else
		error("Failed to list directory: " .. tostring(response))
	end
end

function FileService:ReadFile(filePath)
	local success, response = pcall(function()
		return HttpService:GetAsync(BASE_URL .. "?operation=read&path=" .. filePath)
	end)
	if success then
		return from_base64(response)
	else
		error("Failed to read file: " .. tostring(response))
	end
end

 
function FileService:WriteFile(filePath, fileData)
	local chunks = {}
	local chunkSize = 512 * 1024 -- 512 KB
	local chunksCount = math.ceil(#fileData / chunkSize)

	for i = 1, chunksCount do
		local start = (i - 1) * chunkSize + 1
		local finish = i * chunkSize
		chunks[i] = fileData:sub(start, finish)
	end

	local finalResult = nil
	for i = 1, chunksCount do
		-- Encoded chunk should be sent as raw data (you might need to adjust your function `to_base64` to handle this)
		local chunkData = to_base64(chunks[i])
		-- Additional information about chunk can be sent via URL parameters
		local success, response = pcall(function()
			return HttpService:PostAsync(BASE_URL .. "?operation=write&path=" .. filePath .. "&index=" .. i .. "&total=" .. chunksCount, chunkData)
		end)

		if not success then
			warn("Failed to write file: " .. response)
			return nil
		end
		finalResult = response
	end

	return finalResult
end


return FileService

proxy.js

const http = require('http');
const fs = require('fs');
const url = require('url');
const path = require('path');
const { Buffer } = require('buffer');

const server = http.createServer((req, res) => {
    const queryObject = url.parse(req.url,true).query;
    const operation = queryObject.operation;
    const filePath = path.join(__dirname, queryObject.path);

    switch (operation) {
        case 'list':
            fs.readdir(filePath, (err, files) => {
                if (err) {
                    res.writeHead(500, { 'Content-Type': 'text/plain' });
                    res.write(err.message);
                    res.end();
                } else {
                    let base64Files = files.map(file => Buffer.from(file).toString('base64'));
                    res.writeHead(200, { 'Content-Type': 'application/json' });
                    res.write(JSON.stringify(base64Files));
                    res.end();
                }
            });
            break;
        case 'read':
            fs.readFile(filePath, (err, data) => {
                if (err) {
                    res.writeHead(500, { 'Content-Type': 'text/plain' });
                    res.write(err.message);
                    res.end();
                } else {
                    res.writeHead(200, { 'Content-Type': 'text/plain' });
                    res.write(data.toString('base64'));
                    res.end();
                }
            });
            break;
        case 'write':
            const index = queryObject.index;
            const total = queryObject.total;
            let body = '';
            req.on('data', chunk => {
                body += chunk.toString();
            });
            req.on('end', () => {
                const data = Buffer.from(body, 'base64');
                if (index == total) {
                    fs.writeFile(filePath, data, err => { /*...*/ });
                } else {
                    fs.appendFile(filePath, data, err => { /*...*/ });
                }
            });
            break;
        default:
            res.writeHead(400, { 'Content-Type': 'text/plain' });
            res.write('Invalid operation');
            res.end();
            break;
    }
});

server.listen(3090, () => {
    console.log('Server is listening on port 3090');
});

what the fuck do you do