dc-cloud 0.0.4 → 0.0.6

package/README.md

@@ -2,9 +2,9 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-0.0.1-blue?style=flat-square)](https://github.com/NeelFrostrain/DCloud)
+[![Version](https://img.shields.io/badge/version-0.0.5-blue?style=flat-square)](https://github.com/NeelFrostrain/DCloud)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen?style=flat-square)](https://nodejs.org)
-[![License](https://img.shields.io/badge/license-private-red?style=flat-square)](LICENSE)
+[![License](https://img.shields.io/badge/license-public-blue?style=flat-square)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/typescript-%3E%3D5.0-blue?style=flat-square)](https://www.typescriptlang.org)
 
 **Discord-Based Cloud Storage Solution**

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "dc-cloud",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Discord-based cloud storage solution for file compression, segmentation, and backup using Discord as a backend",
   "type": "module",
   "license":"MIT",
   "module": "dist/index.js",
   "main": "dist/index.js",
-  "types": "index.d.ts",
+  "types": "dist/index.d.ts",
   
   "author": {
     "name": "Neel Frostrain",

package/dist/classes/cloudBot.js

@@ -1,118 +0,0 @@
-import { AttachmentBuilder, ChannelType, Client, GatewayIntentBits, } from "discord.js";
-import chalk from "chalk";
-import fs from "fs";
-let currentActiveThread = null;
-class CloudBotClass extends Client {
-    configOptions;
-    forumChannel = null;
-    currentServer = null;
-    constructor(options) {
-        super({
-            intents: [
-                GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages,
-                GatewayIntentBits.MessageContent,
-            ],
-        });
-        this.configOptions = options;
-    }
-    async Init() {
-        return new Promise(async (resolve, reject) => {
-            try {
-                this.once("clientReady", async () => {
-                    console.log(chalk.green(`[Bot] [Status]: Logged in as ${this.user?.tag}`));
-                    await this.findServer();
-                    await this.findForumChannel();
-                    resolve();
-                });
-                await this.login(this.configOptions.TOKEN);
-            }
-            catch (error) {
-                console.error(chalk.red("[Bot] [Error]: Initialization failed"), error);
-                reject(error);
-            }
-        });
-    }
-    IsBotOnline() {
-        return this.isReady();
-    }
-    async findServer() {
-        try {
-            const guild = await this.guilds.fetch(this.configOptions.SERVER_ID);
-            this.currentServer = guild;
-            console.log(chalk.blue(`[Bot] [Guild]: Connected to Server: ${guild.name}`));
-            return guild;
-        }
-        catch (_e) {
-            throw new Error(`[Bot] [Error]: Could not find server with ID: ${this.configOptions.SERVER_ID}`);
-        }
-    }
-    async findForumChannel() {
-        if (!this.currentServer) {
-            throw new Error("[Bot] [Error]: Cannot find forum: Server not initialized");
-        }
-        try {
-            const channel = await this.currentServer.channels.fetch(this.configOptions.FORUM_CHANNEL_ID);
-            if (!channel || channel.type !== ChannelType.GuildForum) {
-                throw new Error("[Bot] [Error]: Channel ID provided is not a Forum Channel");
-            }
-            this.forumChannel = channel;
-            console.log(chalk.blue(`[Bot] [Channel]: Target Forum: #${this.forumChannel.name}`));
-            return channel;
-        }
-        catch (_e) {
-            throw new Error(`[Bot] [Error]: Could not find forum channel with ID: ${this.configOptions.FORUM_CHANNEL_ID}`);
-        }
-    }
-    async initializeNewThread(name, msg) {
-        if (!this.forumChannel) {
-            console.error(chalk.red("[Bot] [Error]: Forum channel not found during thread creation."));
-            return null;
-        }
-        try {
-            currentActiveThread = await this.forumChannel.threads.create({
-                name: name,
-                message: {
-                    embeds: [msg],
-                },
-            });
-            console.log(chalk.yellow(`[Bot] [Thread]: New Thread Created: ${name}`));
-            return currentActiveThread;
-        }
-        catch (e) {
-            console.error(chalk.red("[Bot] [Error]: Could not create thread:"), e.message);
-            return null;
-        }
-    }
-    async sendToForumChannel(filePath, fileName) {
-        if (!currentActiveThread) {
-            console.error(chalk.red(`[Bot] [Error]: No active thread to upload ${fileName}`));
-            return null;
-        }
-        try {
-            if (!fs.existsSync(filePath)) {
-                throw new Error(`File not found at path: ${filePath}`);
-            }
-            const stats = fs.statSync(filePath);
-            if (stats.size === 0) {
-                throw new Error(`File ${fileName} is empty (0 bytes). Compression may not be finished.`);
-            }
-            const file = new AttachmentBuilder(filePath, { name: fileName });
-            const sentMessage = await currentActiveThread.send({
-                content: `**Segment:** ${fileName}`,
-                files: [file],
-            });
-            console.log(chalk.magenta(`[Bot] [Discord API]: Uploaded ${fileName} (${(stats.size / 1024).toFixed(2)} KB)`));
-            const attachmentLink = sentMessage.attachments.first()?.url;
-            return attachmentLink || null;
-        }
-        catch (e) {
-            console.error(chalk.red(`[Bot] [Error]: Error while uploading ${fileName}:`), e.message);
-            return null;
-        }
-    }
-}
-const CloudBot = (config) => {
-    return new CloudBotClass(config);
-};
-export { CloudBot, CloudBotClass };

package/dist/classes/dCloud.js

@@ -1,164 +0,0 @@
-import { Compress, getDirSize, Restore } from "../utils/7zip.js";
-import { normalize } from "../utils/lib.js";
-import { CloudBot } from "./cloudBot.js";
-import { EmbedBuilder } from "discord.js";
-import path from "path";
-import fs from "fs";
-import chalk from "chalk";
-export class DCloudClass {
-    bot = null;
-    thread = null;
-    inputPath = null;
-    fileMetaData = null;
-    constructor(config) {
-        this.bot = CloudBot(config);
-    }
-    async init() {
-        await this.bot?.Init();
-    }
-    async initializeNewChannel(fileName) {
-        if (!this.bot?.IsBotOnline()) {
-            console.error(chalk.red("[DCloud] [Error]: Bot is not online."));
-            return null;
-        }
-        const channelName = fileName
-            .split(".")[0]
-            .toLowerCase()
-            .replace(/[^a-z0-9-_]/gi, "-");
-        if (!this.inputPath || !fs.existsSync(this.inputPath)) {
-            throw new Error(`[DCloud] [Error]: Input path invalid: ${this.inputPath}`);
-        }
-        const stats = fs.statSync(this.inputPath);
-        const totalByteSize = stats.isDirectory()
-            ? getDirSize(this.inputPath)
-            : stats.size;
-        const sizeInMB = (totalByteSize / (1024 * 1024)).toFixed(2);
-        const embed = new EmbedBuilder()
-            .setTitle("📦 Upload Info")
-            .addFields({ name: "📄 Name", value: fileName, inline: false }, { name: "📏 Size", value: `${sizeInMB} MB`, inline: true })
-            .setColor(0x5865f2);
-        this.thread = await this.bot.initializeNewThread(channelName, embed);
-        if (!this.thread) {
-            throw new Error("[DCloud] [Error]: Failed to initialize Discord thread.");
-        }
-        this.fileMetaData = {
-            originalName: fileName,
-            totalSize: `${sizeInMB} MB`,
-            createdAt: new Date().toLocaleString(),
-            parts: [],
-        };
-        return this.thread;
-    }
-    async upload(_inputPath) {
-        try {
-            this.inputPath = normalize(_inputPath);
-            if (!this.inputPath)
-                return Promise.reject(new Error("[DCloud] [Error]: Invalid input path"));
-            console.log(chalk.cyan("[DCloud] [Process]: Preparing Discord thread..."));
-            const threadReady = await this.initializeNewChannel(path.basename(this.inputPath));
-            if (!threadReady) {
-                throw new Error("[DCloud] [Error]: Discord thread could not be established.");
-            }
-            const _outputPath = path.join(path.dirname(this.inputPath), "TempOutput");
-            if (fs.existsSync(_outputPath)) {
-                fs.rmSync(_outputPath, { recursive: true, force: true });
-            }
-            fs.mkdirSync(_outputPath, { recursive: true });
-            console.log(chalk.yellow("[DCloud] [Process]: Starting compression..."));
-            await Compress(this.inputPath, _outputPath, async (filePath) => {
-                const fileName = path.basename(filePath);
-                let lastSize = -1;
-                let currentSize = 0;
-                while (lastSize !== currentSize || currentSize === 0) {
-                    lastSize = currentSize;
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                    if (fs.existsSync(filePath)) {
-                        currentSize = fs.statSync(filePath).size;
-                    }
-                }
-                console.log(chalk.blue(`[DCloud] [Queue]: Part ready for upload: ${fileName} (${(currentSize / 1024).toFixed(2)} KB)`));
-                const attachmentUrl = await this.bot?.sendToForumChannel(filePath, fileName);
-                if (attachmentUrl && this.fileMetaData) {
-                    this.fileMetaData.parts.push({
-                        name: fileName,
-                        url: attachmentUrl,
-                    });
-                }
-            });
-            this.fileMetaData?.parts.sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
-            console.log(chalk.green("[DCloud] [Success]: Compression and Upload sequence complete."));
-            const metaDataPath = path.join(_outputPath, "metadata.json");
-            fs.writeFileSync(metaDataPath, JSON.stringify(this.fileMetaData, null, 2));
-            const metadataUrl = await this.bot?.sendToForumChannel(metaDataPath, "metadata.json");
-            await this.thread?.send({
-                content: metadataUrl?.toString(),
-            });
-            if (!metadataUrl)
-                throw new Error("[DCloud] [Error]: Metadata upload failed.");
-            fs.rmSync(_outputPath, { recursive: true, force: true });
-            return {
-                originalName: this.fileMetaData?.originalName || "",
-                totalSize: this.fileMetaData?.totalSize || "",
-                createdAt: this.fileMetaData?.createdAt || "",
-                metadata: metadataUrl,
-            };
-        }
-        catch (error) {
-            console.error(chalk.red("[DCloud] [Error]: Process Failed:"), error?.message || error);
-            this.fileMetaData = null;
-            throw error;
-        }
-    }
-    async downloader(attachmentUrl, output) {
-        const normalizedOutput = normalize(output);
-        if (!normalizedOutput)
-            return;
-        const metadataRes = await fetch(attachmentUrl);
-        if (!metadataRes.ok)
-            throw new Error(`[DCloud] [Error]: Metadata fetch failed: ${metadataRes.status}`);
-        const metadataBuffer = Buffer.from(await metadataRes.arrayBuffer());
-        const fileData = JSON.parse(metadataBuffer.toString());
-        const folderPath = path.join(normalizedOutput, fileData.originalName.split(".")[0]);
-        if (!fs.existsSync(folderPath))
-            fs.mkdirSync(folderPath, { recursive: true });
-        const metadataPath = path.join(folderPath, "metadata.json");
-        fs.writeFileSync(metadataPath, metadataBuffer);
-        const downloadParts = fileData.parts;
-        if (downloadParts.length === 0)
-            return;
-        console.log(chalk.yellow(`[Downloader] [Info]: Found ${downloadParts.length} parts. Starting download...`));
-        let partIndex = 1;
-        for (const part of downloadParts) {
-            console.log(chalk.blue(`[Downloader] [Transfer]: Fetching part ${partIndex}: ${part.name}...`));
-            const filePartsRes = await fetch(part.url);
-            if (!filePartsRes.ok)
-                throw new Error(`[Downloader] [Error]: Failed to download part: ${filePartsRes.status}`);
-            const partBuffer = Buffer.from(await filePartsRes.arrayBuffer());
-            const _savePath = path.join(folderPath, part.name);
-            fs.writeFileSync(_savePath, partBuffer);
-            console.log(chalk.green(`[Downloader] [Success]: Saved: ${part.name}`));
-            partIndex++;
-        }
-        console.log(chalk.cyan("[DCloud] [Restore]: All parts downloaded. Starting Restore..."));
-        await Restore(folderPath);
-        console.log(chalk.yellow("[DCloud] [Cleanup]: Cleaning up temporary archive parts..."));
-        try {
-            for (const part of downloadParts) {
-                const partPath = path.join(folderPath, part.name);
-                if (fs.existsSync(partPath)) {
-                    fs.unlinkSync(partPath);
-                }
-            }
-            if (fs.existsSync(metadataPath)) {
-                fs.unlinkSync(metadataPath);
-            }
-            console.log(chalk.green("[DCloud] [Success]: Cleanup complete. Only the extracted files remain."));
-        }
-        catch (err) {
-            console.error(chalk.red("[DCloud] [Error]: Cleanup failed:"), err.message);
-        }
-    }
-}
-export const DCloud = (config) => {
-    return new DCloudClass(config);
-};

package/dist/index.js

@@ -1,2 +0,0 @@
-export { DCloud, DCloudClass } from "./classes/dCloud.js";
-export { CloudBot, CloudBotClass } from "./classes/cloudBot.js";

package/dist/interface/index.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/7zip.js

@@ -1,171 +0,0 @@
-import { path7za } from "7zip-bin";
-import { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { exists, normalize } from "./lib.js";
-import path from "node:path";
-import fs from "fs";
-import chalk from "chalk";
-export const SEVEN_ZIP = path7za;
-/**
- * Executes a 7z command process
- */
-export function run7z(args, onDone, onFailed) {
-    if (!existsSync(SEVEN_ZIP)) {
-        console.error(chalk.red("[7z] [Error]: 7-Zip binary not found."));
-        onFailed?.();
-        return;
-    }
-    const proc = spawn(SEVEN_ZIP, args, {
-        stdio: "pipe",
-        shell: false,
-    });
-    proc.on("close", (code) => {
-        process.stdout.write("\n");
-        if (code === 0) {
-            onDone();
-        }
-        else {
-            onFailed();
-        }
-    });
-    proc.on("error", (err) => {
-        console.error(chalk.red("[7z] [Error]: Execution failed:"), err);
-        onFailed();
-    });
-}
-/**
- * Watches for specific 7z split parts being created
- */
-export function fileWatcher(dir, baseName, callback) {
-    const seenFile = new Set();
-    return fs.watch(dir, (eventType, fileName) => {
-        if (fileName &&
-            fileName.startsWith(baseName) &&
-            fileName.includes(".7z.")) {
-            if (!seenFile.has(fileName)) {
-                seenFile.add(fileName);
-                callback(fileName);
-            }
-        }
-    });
-}
-/**
- * Compresses input into split 7z archives and triggers upload tasks
- */
-export async function Compress(input, outPut, onNewFileCreated) {
-    const inputPath = normalize(input);
-    const outPutPath = normalize(outPut);
-    if (!exists(inputPath || "") || !inputPath || !outPutPath) {
-        console.error(chalk.red("[7z] [Error]: Input path does not exist"));
-        return null;
-    }
-    const baseName = path.basename(inputPath);
-    const archiveBase = path.join(outPutPath, baseName);
-    if (exists(outPutPath)) {
-        fs.rmSync(outPutPath, { recursive: true, force: true });
-    }
-    fs.mkdirSync(outPutPath, { recursive: true });
-    const uploadPromises = [];
-    const watcher = fileWatcher(outPutPath, baseName, (fileName) => {
-        const fullPath = path.join(outPutPath, fileName);
-        const uploadTask = onNewFileCreated(fullPath);
-        uploadPromises.push(uploadTask);
-    });
-    const stats = fs.statSync(inputPath);
-    const totalByteSize = stats.isDirectory()
-        ? getDirSize(inputPath)
-        : stats.size;
-    const sizeInMB = (totalByteSize / (1024 * 1024)).toFixed(2);
-    const args = [
-        "a",
-        "-t7z",
-        "-mx=9",
-        "-m0=lzma2",
-        "-md=512m",
-        "-ms=on",
-        "-bsp1",
-        "-bb3",
-        "-v8m",
-        `${archiveBase}.7z`,
-        inputPath,
-    ];
-    return new Promise((resolve, reject) => {
-        run7z(args, async () => {
-            watcher.close();
-            console.log(chalk.yellow(`[7z] [Process]: Waiting for ${uploadPromises.length} uploads to finalize...`));
-            const uploadedParts = (await Promise.all(uploadPromises)).filter((p) => p !== null);
-            uploadedParts.sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
-            const result = {
-                originalName: baseName,
-                createdAt: new Date().toISOString(),
-                totalSize: `${sizeInMB} MB`,
-                parts: uploadedParts,
-            };
-            resolve(result);
-        }, (err) => {
-            watcher.close();
-            console.error(chalk.red("[7z] [Error]: 7zip Failed To Compile"), err);
-            reject(new Error(err || "7zip failed"));
-        });
-    });
-}
-/**
- * Restores a split archive back to its original form
- */
-export async function Restore(folder, destination, onDone, onFailed) {
-    return new Promise(async (resolve, reject) => {
-        const folderPath = normalize(folder);
-        if (!folderPath)
-            return reject(new Error("[7z] [Error]: Invalid folder path"));
-        const indexPath = path.join(folderPath, "metadata.json");
-        if (!exists(indexPath)) {
-            console.error(chalk.red(`[7z] [Error]: metadata.json not found in ${folderPath}`));
-            return reject(new Error("metadata.json missing"));
-        }
-        const metadata = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
-        if (!metadata.parts || !metadata.parts.length) {
-            return reject(new Error("[7z] [Error]: No parts found in metadata"));
-        }
-        const fileNameArray = metadata.parts.map((part) => part.name);
-        const firstPart = path.join(folderPath, fileNameArray[0]);
-        if (!exists(firstPart)) {
-            console.error(chalk.red(`[7z] [Error]: First part missing: ${firstPart}`));
-            return reject(new Error("First archive part missing"));
-        }
-        const outDir = destination ? normalize(destination) : folderPath;
-        if (!outDir)
-            return reject(new Error("[7z] [Error]: Invalid output directory"));
-        const args = ["x", firstPart, `-o${outDir}`, "-aoa", "-y"];
-        const on7zDone = () => {
-            console.log(chalk.green("[7z] [Restore]: Extraction completed successfully."));
-            if (onDone)
-                onDone();
-            resolve();
-        };
-        const on7zFailed = () => {
-            console.error(chalk.red("[7z] [Restore]: Extraction failed."));
-            if (onFailed)
-                onFailed();
-            reject(new Error("7-Zip extraction failed"));
-        };
-        run7z(args, () => on7zDone(), () => on7zFailed());
-    });
-}
-/**
- * Recursively calculates directory size in bytes
- */
-export function getDirSize(dirPath) {
-    const files = fs.readdirSync(dirPath);
-    let totalSize = 0;
-    files.forEach((file) => {
-        const filePath = path.join(dirPath, file);
-        const stats = fs.statSync(filePath);
-        if (stats.isDirectory()) {
-            totalSize += getDirSize(filePath);
-        }
-        else {
-            totalSize += stats.size;
-        }
-    });
-    return totalSize;
-}

package/dist/utils/lib.js

@@ -1,12 +0,0 @@
-import path from "path";
-import fs from "fs";
-export function normalize(filePath) {
-    if (!filePath || typeof filePath !== "string")
-        return null;
-    return path.resolve(filePath.replace(/["']/g, ""));
-}
-export function exists(filePath) {
-    if (!fs.existsSync(filePath))
-        return false;
-    return true;
-}