dc-cloud 0.0.1

package/dist/classes/dCloud.js

@@ -0,0 +1,164 @@
+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(undefined);
+            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

@@ -0,0 +1,10 @@
+import { DCloud } from "./classes/dCloud.js";
+const TOKEN = "MTQxODYyMjg0MDE4NTQyMTgzNg.Gtq4z_.FT7e39PscQjNet23o4TfMBzYVAMbG_TzkjQ9a8";
+const CHANNEL_ID = "1465235994243502162";
+const GUILD_ID = "1316439358609297418";
+const dCloud = DCloud({ FORUM_CHANNEL_ID: CHANNEL_ID, TOKEN: TOKEN, SERVER_ID: GUILD_ID });
+dCloud.init();
+setTimeout(() => {
+    dCloud.upload("C:\\Users\\neelo\\OneDrive\\Desktop\\DCloud\\text.txt");
+}, 10000);
+// dCloud.downloader("https://cdn.discordapp.com/attachments/1465344532462702639/1465344646329929923/metadata.json?ex=6978c40c&is=6977728c&hm=3b51d006d31594712dbc8c76c5a5b24d83c01c4b6d9bf8339ed175f9c5114e4a&", "..")

package/dist/interface/index.js

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

package/dist/utils/7zip.js

@@ -0,0 +1,169 @@
+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;
+        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

@@ -0,0 +1,12 @@
+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;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "dc-cloud",
+  "version": "0.0.1",
+  "description": "Discord-based cloud storage solution for file compression, segmentation, and backup using Discord as a backend",
+  "type": "module",
+  "module": "dist/index.js",
+  "main": "dist/index.js",
+  
+  "author": {
+    "name": "Neel Frostrain",
+    "url": "https://github.com/NeelFrostrain"
+  },
+  
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NeelFrostrain/DCloud.git"
+  },
+  
+  "keywords": [
+    "discord",
+    "cloud-storage",
+    "compression",
+    "7zip",
+    "file-backup",
+    "bot"
+  ],
+  
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  },
+  
+  "scripts": {
+    "start": "npm run build && node dist/index.js",
+    "dev": "nodemon --exec ts-node src/index.ts",
+    "build": "tsc",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit"
+  },
+  
+  "dependencies": {
+    "7zip-bin": "^5.2.0",
+    "chalk": "^5.6.2",
+    "discord.js": "^14.25.1"
+  },
+  
+  "devDependencies": {
+    "eslint": "^9.39.2",
+    "globals": "^17.1.0",
+    "jiti": "^2.6.1",
+    "nodemon": "^3.1.11",
+    "typescript-eslint": "^8.53.1"
+  },
+  
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}