virtualfile-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sudesh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,222 @@
+# ViewFile
+
+ViewFile is a command-line interface (CLI) application that allows you to create, read, edit, and delete text files stored in the cloud. It provides a simple way to access your notes or text content from any machine without relying on local storage.
+
+The project consists of a Node.js CLI client and a REST API backend, making it lightweight, fast, and easy to use from the terminal.
+
+---
+
+## Features
+
+- Create cloud-based text files
+- Read files directly from the terminal
+- Edit existing files using your default text editor
+- Delete files
+- Simple and intuitive command-line interface
+- Cross-platform support (Windows and Linux)
+- REST API powered backend
+- Global CLI installation via npm
+
+---
+
+## Installation
+
+### Prerequisites
+
+- Node.js 18 or later
+- npm
+
+### Install globally
+
+```bash
+npm install -g viewfile
+```
+
+Verify the installation:
+
+```bash
+vf --version
+```
+
+---
+
+## Usage
+
+### Create a file
+
+```bash
+vf -w <filename>
+```
+
+Example:
+
+```bash
+vf -w notes
+```
+
+This creates a new cloud file and opens your default editor to write its contents.
+
+---
+
+### Read a file
+
+```bash
+vf -r <filename>
+```
+
+Example:
+
+```bash
+vf -r notes
+```
+
+Displays the contents of the specified file.
+
+---
+
+### Edit a file
+
+```bash
+vf -e <filename>
+```
+
+Example:
+
+```bash
+vf -e notes
+```
+
+Opens the existing file in your default editor. Changes are automatically saved back to the cloud.
+
+---
+
+### Delete a file
+
+```bash
+vf -rm <filename>
+```
+
+Example:
+
+```bash
+vf -rm notes
+```
+
+Deletes the specified file from the server.
+
+---
+
+## Command Reference
+
+| Command | Description |
+|---------|-------------|
+| `vf -w <filename>` | Create a new file |
+| `vf -r <filename>` | Read an existing file |
+| `vf -e <filename>` | Edit an existing file |
+| `vf -rm <filename>` | Delete a file |
+| `vf --help` | Display help information |
+| `vf --version` | Display the installed version |
+
+---
+
+## Example Workflow
+
+Create a file:
+
+```bash
+vf -w todo
+```
+
+Read the file:
+
+```bash
+vf -r todo
+```
+
+Edit the file:
+
+```bash
+vf -e todo
+```
+
+Delete the file:
+
+```bash
+vf -rm todo
+```
+
+---
+
+## Use Cases
+
+- Store quick notes accessible from anywhere
+- Maintain terminal-based documentation
+- Save code snippets
+- Store TODO lists
+- Keep configuration notes
+- Manage text without depending on local files
+
+---
+
+## Technology Stack
+
+### Client
+
+- Node.js
+- Axios
+- Chalk
+- Dotenv
+
+### Server
+
+- Node.js
+- Express.js
+- MongoDB Atlas
+- Mongoose
+
+### Deployment
+
+- Render
+
+---
+
+## Project Structure
+
+```
+ViewFile/
+├── client/
+│   ├── commands/
+│   ├── services/
+│   ├── utils/
+│   └── index.js
+│
+├── server/
+│   ├── controllers/
+│   ├── models/
+│   ├── routes/
+│   ├── config/
+│   └── app.js
+│
+├── package.json
+└── README.md
+```
+
+---
+
+## Requirements
+
+- Node.js 18+
+- Internet connection
+- npm
+
+---
+
+## License
+
+This project is licensed under the MIT License.
+
+---
+
+## Author
+
+Developed by Sudesh.

package/client/commands/delete.js

@@ -0,0 +1,21 @@
+const { deleteFile } = require("../services/api");
+const logger = require("../utils/logger");
+
+async function remove(filename) {
+    if (!filename) {
+        logger.error("Usage: vf -rm <filename>");
+        return;
+    }
+
+    try {
+        logger.info(`Deleting "${filename}"...`);
+
+        await deleteFile(filename);
+
+        logger.success("File deleted successfully.");
+    } catch (err) {
+        logger.error(err.response?.data?.message || err.message);
+    }
+}
+
+module.exports = remove;

package/client/commands/edit.js

@@ -0,0 +1,35 @@
+const openEditor = require("../utils/editor");
+const {
+    getFile,
+    updateFile,
+} = require("../services/api");
+const logger = require("../utils/logger");
+
+async function edit(filename) {
+
+    if (!filename) {
+        logger.error("Usage: vf -e <filename>");
+        return;
+    }
+
+    try {
+
+        const file = await getFile(filename);
+
+        logger.info("Opening editor...");
+
+        const updatedContent = await openEditor(
+            filename,
+            file.content
+        );
+
+        await updateFile(filename, updatedContent);
+
+        logger.success("File updated successfully.");
+
+    } catch (err) {
+        logger.error(err.response?.data?.message || err.message);
+    }
+}
+
+module.exports = edit;

package/client/commands/list.js

@@ -0,0 +1,26 @@
+const chalk = require("chalk");
+const { listFiles } = require("../services/api");
+const logger = require("../utils/logger");
+
+async function list() {
+    try {
+        const files = await listFiles();
+
+        if (files.length === 0) {
+            logger.warning("No files found.");
+            return;
+        }
+
+        logger.title(`Files (${files.length})`);
+        console.log(chalk.blue("─".repeat(60)));
+
+        files.forEach(file => {
+            console.log(`${chalk.green("📄")} ${chalk.white(file.filename)}`);
+        });
+
+    } catch (err) {
+        logger.error(err.response?.data?.message || err.message);
+    }
+}
+
+module.exports = list;

package/client/commands/read.js

@@ -0,0 +1,24 @@
+const chalk = require("chalk");
+const { getFile } = require("../services/api");
+const logger = require("../utils/logger");
+
+async function read(filename) {
+    if (!filename) {
+        logger.error("Usage: vf -r <filename>");
+        return;
+    }
+
+    try {
+        const file = await getFile(filename);
+
+        console.log(chalk.blue("─".repeat(60)));
+        logger.title(filename);
+        console.log(chalk.blue("─".repeat(60)));
+        console.log(file.content);
+
+    } catch (err) {
+        logger.error(err.response?.data?.message || err.message);
+    }
+}
+
+module.exports = read;

package/client/commands/write.js

@@ -0,0 +1,35 @@
+const openEditor = require("../utils/editor");
+const {
+    fileExists,
+    createFile,
+} = require("../services/api");
+const logger = require("../utils/logger");
+
+async function write(filename) {
+    if (!filename) {
+        logger.error("Usage: vf -w <filename>");
+        return;
+    }
+
+    const exists = await fileExists(filename);
+
+    if (exists) {
+        logger.warning(`File "${filename}" already exists.`);
+        logger.info(`Use: vf -e ${filename}`);
+        return;
+    }
+
+    try {
+        logger.info("Opening editor...");
+
+        const content = await openEditor(filename);
+
+        await createFile(filename, content);
+
+        logger.success("File saved successfully.");
+    } catch (err) {
+        logger.error(err.message);
+    }
+}
+
+module.exports = write;

package/client/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+require("dotenv").config({ quiet: true });
+const write = require("./commands/write");
+const read = require("./commands/read");
+const list = require("./commands/list");
+const remove = require("./commands/delete");
+const edit = require("./commands/edit");
+const logger = require("./utils/logger");
+
+const { version } = require("../package.json");
+
+const args = process.argv.slice(2);
+
+function showHelp() {
+    logger.title("ViewFile CLI");
+    console.log(`Version ${version}
+
+Usage:
+  vf -w <filename>      Create a new file
+  vf -e <filename>      Edit an existing file
+  vf -r <filename>      Read a file
+  vf -rm <filename>     Delete a file
+
+Options:
+  --help                Show this help message
+  --version             Show CLI version
+`);
+}
+
+async function main() {
+
+    if (args.length === 0) {
+        showHelp();
+        return;
+    }
+
+    const command = args[0];
+
+    switch (command) {
+
+        case "-w":
+            await write(args[1]);
+            break;
+
+        case "-e":
+            await edit(args[1]);
+            break;
+
+        case "-r":
+            await read(args[1]);
+            break;
+
+        case "-rm":
+            await remove(args[1]);
+            break;
+
+        // case "ls":
+        //     await list();
+        //     break;
+
+        case "--help":
+        case "-h":
+            showHelp();
+            break;
+
+        case "--version":
+        case "-v":
+            console.log(`ViewFile CLI v${version}`);
+            break;
+
+        default:
+            logger.error(`Unknown command "${command}"`);
+            console.log();
+            logger.info('Run "vf --help" to see available commands.');
+    }
+}
+
+main();

package/client/services/api.js

@@ -0,0 +1,59 @@
+const axios = require("axios");
+
+const BASE_URL = process.env.API_URL || "https://viewfile-6xjx.onrender.com";
+
+const API = `${BASE_URL}/files`;
+
+async function createFile(filename, content) {
+    const res = await axios.post(API, {
+        filename,
+        content,
+    });
+
+    return res.data;
+}
+
+async function updateFile(filename, content) {
+    const res = await axios.put(`${API}/${filename}`, {
+        content,
+    });
+
+    return res.data;
+}
+
+async function getFile(filename) {
+    const res = await axios.get(`${API}/${filename}`);
+    return res.data;
+}
+
+async function fileExists(filename) {
+    try {
+        await axios.get(`${API}/${filename}`);
+        return true;
+    } catch (err) {
+        if (err.response?.status === 404) {
+            return false;
+        }
+
+        throw err;
+    }
+}
+
+async function listFiles() {
+    const res = await axios.get(API);
+    return res.data;
+}
+
+async function deleteFile(filename) {
+    const res = await axios.delete(`${API}/${filename}`);
+    return res.data;
+}
+
+module.exports = {
+    createFile,
+    updateFile,
+    getFile,
+    listFiles,
+    deleteFile,
+    fileExists
+};

package/client/utils/editor/buffer.js

@@ -0,0 +1,85 @@
+class Buffer {
+
+    constructor(initialContent = "") {
+
+        this.lines =
+            initialContent.length > 0
+                ? initialContent.split("\n")
+                : [""];
+    }
+
+    line(y) {
+        return this.lines[y];
+    }
+
+    lineCount() {
+        return this.lines.length;
+    }
+
+    insert(x, y, char) {
+
+        const line = this.lines[y];
+
+        this.lines[y] =
+            line.slice(0, x) +
+            char +
+            line.slice(x);
+    }
+
+    deleteBackward(x, y) {
+
+        if (x > 0) {
+
+            const line = this.lines[y];
+
+            this.lines[y] =
+                line.slice(0, x - 1) +
+                line.slice(x);
+
+            return {
+                x: x - 1,
+                y
+            };
+        }
+
+        if (y > 0) {
+
+            const previousLength =
+                this.lines[y - 1].length;
+
+            this.lines[y - 1] += this.lines[y];
+
+            this.lines.splice(y, 1);
+
+            return {
+                x: previousLength,
+                y: y - 1
+            };
+        }
+
+        return { x, y };
+    }
+
+    newline(x, y) {
+
+        const current = this.lines[y];
+
+        const left = current.slice(0, x);
+        const right = current.slice(x);
+
+        this.lines[y] = left;
+
+        this.lines.splice(y + 1, 0, right);
+
+        return {
+            x: 0,
+            y: y + 1
+        };
+    }
+
+    toString() {
+        return this.lines.join("\n");
+    }
+}
+
+module.exports = Buffer;

package/client/utils/editor/cursor.js

@@ -0,0 +1,82 @@
+class Cursor {
+
+    constructor(buffer) {
+        this.buffer = buffer;
+
+        this.x = 0;
+        this.y = 0;
+    }
+
+    loadToEnd() {
+        this.y = this.buffer.lineCount() - 1;
+        this.x = this.buffer.line(this.y).length;
+    }
+
+    left() {
+
+        if (this.x > 0) {
+            this.x--;
+        }
+        else if (this.y > 0) {
+            this.y--;
+            this.x = this.buffer.line(this.y).length;
+        }
+    }
+
+    right() {
+
+        if (this.x < this.buffer.line(this.y).length) {
+            this.x++;
+        }
+        else if (this.y < this.buffer.lineCount() - 1) {
+            this.y++;
+            this.x = 0;
+        }
+    }
+
+    up() {
+
+        if (this.y > 0) {
+            this.y--;
+
+            this.x = Math.min(
+                this.x,
+                this.buffer.line(this.y).length
+            );
+        }
+    }
+
+    down() {
+
+        if (this.y < this.buffer.lineCount() - 1) {
+            this.y++;
+
+            this.x = Math.min(
+                this.x,
+                this.buffer.line(this.y).length
+            );
+        }
+    }
+
+    home() {
+        this.x = 0;
+    }
+
+    end() {
+        this.x = this.buffer.line(this.y).length;
+    }
+
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    position() {
+        return {
+            x: this.x,
+            y: this.y
+        };
+    }
+}
+
+module.exports = Cursor;

package/client/utils/editor/index.js

@@ -0,0 +1,33 @@
+const { terminal: term } = require("terminal-kit");
+
+const Buffer = require("./buffer");
+const Cursor = require("./cursor");
+const Viewport = require("./viewport");
+const Renderer = require("./renderer");
+const Input = require("./input");
+
+async function openEditor(filename, initialContent = "") {
+
+    const buffer = new Buffer(initialContent);
+
+    const cursor = new Cursor(buffer);
+    cursor.loadToEnd();
+
+    const viewport = new Viewport(term, 5);
+
+    const renderer = new Renderer(
+        buffer,
+        cursor,
+        viewport
+    );
+
+    const input = new Input(
+        buffer,
+        cursor,
+        renderer
+    );
+
+    return await input.start(filename);
+}
+
+module.exports = openEditor;

package/client/utils/editor/input.js

@@ -0,0 +1,135 @@
+const { terminal: term } = require("terminal-kit");
+
+class Input {
+
+    constructor(buffer, cursor, renderer) {
+        this.buffer = buffer;
+        this.cursor = cursor;
+        this.renderer = renderer;
+
+        this.renderScheduled = false;
+    }
+
+    scheduleRender(filename) {
+
+        if (this.renderScheduled) return;
+
+        this.renderScheduled = true;
+
+        setImmediate(() => {
+            this.renderer.draw(filename);
+            this.renderScheduled = false;
+        });
+    }
+
+    start(filename) {
+
+        return new Promise((resolve, reject) => {
+
+            // Initial render
+            this.renderer.draw(filename);
+
+            term.grabInput(true);
+
+            const cleanup = () => {
+
+                term.removeListener("key", onKey);
+                term.grabInput(false);
+
+                if (typeof term.hideCursor === "function") {
+                    term.hideCursor(false);
+                }
+
+                term.styleReset();
+                term.clear();
+                term.moveTo(1, 1);
+            };
+
+            const onKey = (name) => {
+
+                switch (name) {
+
+                    case "CTRL_S":
+                        cleanup();
+                        resolve(this.buffer.toString());
+                        return;
+
+                    case "ESCAPE":
+                        cleanup();
+                        reject(new Error("Cancelled"));
+                        return;
+
+                    case "LEFT":
+                        this.cursor.left();
+                        break;
+
+                    case "RIGHT":
+                        this.cursor.right();
+                        break;
+
+                    case "UP":
+                        this.cursor.up();
+                        break;
+
+                    case "DOWN":
+                        this.cursor.down();
+                        break;
+
+                    case "HOME":
+                        this.cursor.home();
+                        break;
+
+                    case "END":
+                        this.cursor.end();
+                        break;
+
+                    case "ENTER": {
+
+                        const pos = this.buffer.newline(
+                            this.cursor.x,
+                            this.cursor.y
+                        );
+
+                        this.cursor.set(pos.x, pos.y);
+                        break;
+                    }
+
+                    case "BACKSPACE": {
+
+                        const pos = this.buffer.deleteBackward(
+                            this.cursor.x,
+                            this.cursor.y
+                        );
+
+                        this.cursor.set(pos.x, pos.y);
+                        break;
+                    }
+
+                    default:
+
+                        if (name.length === 1) {
+
+                            this.buffer.insert(
+                                this.cursor.x,
+                                this.cursor.y,
+                                name
+                            );
+
+                            this.cursor.x++;
+                        }
+
+                        break;
+                }
+
+                this.scheduleRender(filename);
+            };
+
+            term.on("key", onKey);
+
+        });
+
+    }
+
+}
+
+module.exports = Input;

package/client/utils/editor/renderer.js

@@ -0,0 +1,89 @@
+const { terminal: term } = require("terminal-kit");
+
+class Renderer {
+    constructor(buffer, cursor, viewport) {
+        this.buffer = buffer;
+        this.cursor = cursor;
+        this.viewport = viewport;
+    }
+
+    draw(filename) {
+
+        // Hide cursor while drawing
+        if (term.hideCursor) {
+            term.hideCursor(true);
+        }
+
+        term.moveTo(1, 1);
+
+        // Some versions don't support eraseDisplayBelow()
+        if (typeof term.eraseDisplayBelow === "function") {
+            term.eraseDisplayBelow();
+        } else {
+            term.clear();
+        }
+
+        // Header
+        term.bold.cyan("ViewFile\n");
+
+        term.gray("Editing: ");
+        term.green(filename);
+        term("\n");
+
+        term.gray("Ctrl+S Save | Esc Cancel | Arrows Move\n");
+        term("──────────────────────────────────────────────\n");
+
+        // Keep cursor visible
+        this.viewport.update(this.cursor.y);
+
+        const start = this.viewport.firstLine();
+        const end = this.viewport.lastLine(this.buffer);
+
+        // Draw only visible lines
+        for (let i = start; i < end; i++) {
+
+            const lineNumber = String(i + 1).padStart(4);
+
+            term.gray(lineNumber);
+            term.gray(" │ ");
+
+            term(this.buffer.line(i));
+            term("\n");
+        }
+
+        // Fill remaining editor area
+        const drawn = end - start;
+        const remaining = Math.max(
+            0,
+            this.viewport.visibleHeight() - drawn - 1
+        );
+
+        for (let i = 0; i < remaining; i++) {
+            term.gray("     │\n");
+        }
+
+        // Draw status bar at bottom
+        term.moveTo(1, term.height);
+
+        term.moveTo(1, term.height);
+
+term.eraseLine();
+
+term.inverse(
+    ` Ln ${this.cursor.y + 1} | Col ${this.cursor.x + 1} | ${this.buffer.lineCount()} lines `
+);
+
+        // Cursor position
+        term.moveTo(
+            this.cursor.x + 8,
+            this.viewport.screenY(this.cursor.y)
+        );
+
+        // Show cursor again
+        if (term.hideCursor) {
+            term.hideCursor(false);
+        }
+    }
+}
+
+module.exports = Renderer;

package/client/utils/editor/viewport.js

@@ -0,0 +1,48 @@
+class Viewport {
+
+    constructor(term, headerHeight = 6) {
+
+        this.term = term;
+        this.headerHeight = headerHeight;
+
+        this.scrollY = 0;
+    }
+
+    visibleHeight() {
+        return this.term.height - this.headerHeight;
+    }
+
+    update(cursorY) {
+
+        const visible = this.visibleHeight();
+
+        // Scroll up
+        if (cursorY < this.scrollY) {
+            this.scrollY = cursorY;
+        }
+
+        // Scroll down
+        else if (cursorY >= this.scrollY + visible) {
+            this.scrollY = cursorY - visible + 1;
+        }
+    }
+
+    firstLine() {
+        return this.scrollY;
+    }
+
+    lastLine(buffer) {
+
+        return Math.min(
+            buffer.lineCount(),
+            this.scrollY + this.visibleHeight()
+        );
+    }
+
+    screenY(cursorY) {
+        return (cursorY - this.scrollY) + this.headerHeight;
+    }
+
+}
+
+module.exports = Viewport;

package/client/utils/logger.js

@@ -0,0 +1,29 @@
+const chalk = require("chalk");
+
+module.exports = {
+
+    success(message) {
+        console.log(chalk.green(`✓ ${message}`));
+    },
+
+    error(message) {
+        console.log(chalk.red(`✗ ${message}`));
+    },
+
+    warning(message) {
+        console.log(chalk.yellow(`⚠ ${message}`));
+    },
+
+    info(message) {
+        console.log(chalk.cyan(`ℹ ${message}`));
+    },
+
+    title(message) {
+        console.log(chalk.bold.blue(message));
+    },
+
+    plain(message) {
+        console.log(message);
+    }
+
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "virtualfile-cli",
+  "version": "1.0.0",
+  "description": "A terminal-based cloud text file storage CLI.",
+  "bin": {
+    "vf": "client/index.js"
+  },
+  "scripts": {
+    "start": "node server/app.js",
+    "dev": "nodemon server/app.js"
+  },
+  "keywords": [
+    "cli",
+    "terminal",
+    "text",
+    "cloud",
+    "notes",
+    "nodejs"
+  ],
+  "author": "Sudesh",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.18.1",
+    "bcryptjs": "^3.0.3",
+    "chalk": "^4.1.2",
+    "cors": "^2.8.6",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3",
+    "mongoose": "^9.7.4",
+    "ora": "^5.4.1",
+    "terminal-kit": "^3.1.4"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.14"
+  }
+}

package/server/app.js

@@ -0,0 +1,25 @@
+const express = require("express");
+const dotenv = require("dotenv");
+const cors = require("cors");
+
+const connectDB = require("./config/db");
+const fileRoutes = require("./routes/fileRoutes");
+
+dotenv.config();
+
+connectDB();
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+app.use("/files", fileRoutes);
+app.get("/", (req, res) => {
+    res.send("ViewFile API Running...");
+});
+
+const PORT = process.env.PORT || 5000;
+
+app.listen(PORT, () => {
+    console.log(`🚀 Server running on port ${PORT}`);
+});

package/server/config/db.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect(process.env.MONGO_URI);
+        console.log("MongoDB Connected");
+    } catch (error) {
+        console.error(" Database Connection Failed");
+        console.error(error.message);
+        process.exit(1);
+    }
+};
+
+module.exports = connectDB;

package/server/controllers/fileController.js

@@ -0,0 +1,100 @@
+const File = require("../models/File");
+
+const createFile = async (req, res) => {
+    try {
+        const { filename, content } = req.body;
+
+        const existing = await File.findOne({ filename });
+
+        if (existing) {
+            return res.status(409).json({
+                message: "File already exists",
+            });
+        }
+
+        const file = await File.create({
+            filename,
+            content,
+        });
+
+        res.status(201).json(file);
+
+    } catch (error) {
+        res.status(500).json({
+            message: error.message,
+        });
+    }
+};
+
+const getFile = async (req, res) => {
+    try {
+        const file = await File.findOne({ filename: req.params.filename });
+
+        if (!file) {
+            return res.status(404).json({ message: "File not found" });
+        }
+
+        res.json(file);
+    } catch (error) {
+        res.status(500).json({ message: error.message });
+    }
+};
+
+const deleteFile = async (req, res) => {
+    try {
+        const file = await File.findOneAndDelete({
+            filename: req.params.filename,
+        });
+
+        if (!file) {
+            return res.status(404).json({ message: "File not found" });
+        }
+
+        res.json({ message: "File deleted successfully" });
+    } catch (error) {
+        res.status(500).json({ message: error.message });
+    }
+};
+
+const listFiles = async (req, res) => {
+    try {
+        const files = await File.find({}, "filename");
+        res.json(files);
+    } catch (error) {
+        res.status(500).json({ message: error.message });
+    }
+};
+
+const updateFile = async (req, res) => {
+    try {
+
+        const file = await File.findOne({
+            filename: req.params.filename,
+        });
+
+        if (!file) {
+            return res.status(404).json({
+                message: "File not found",
+            });
+        }
+
+        file.content = req.body.content;
+
+        await file.save();
+
+        res.json(file);
+
+    } catch (error) {
+        res.status(500).json({
+            message: error.message,
+        });
+    }
+};
+
+module.exports = {
+    createFile,
+    getFile,
+    deleteFile,
+    updateFile,
+    listFiles
+};

package/server/models/File.js

@@ -0,0 +1,21 @@
+const mongoose = require("mongoose");
+
+const fileSchema = new mongoose.Schema(
+  {
+    filename: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true
+    },
+    content: {
+      type: String,
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+module.exports = mongoose.model("File", fileSchema);

package/server/routes/fileRoutes.js

@@ -0,0 +1,16 @@
+const express = require("express");
+const router = express.Router();
+
+const { createFile, getFile, deleteFile, listFiles, updateFile } = require("../controllers/fileController");
+
+router.post("/", createFile);
+
+router.put("/:filename", updateFile);
+
+router.get("/", listFiles);
+
+router.get("/:filename", getFile);
+
+router.delete("/:filename", deleteFile);
+
+module.exports = router;