npm - @jisan901/fs-browser - Versions diffs - 1.0.0 → 1.0.2 - Mend

@jisan901/fs-browser 1.0.0 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -1,4 +1,4 @@
-# fs-browser
+# @jisan901/fs-browser
 Browser-compatible filesystem API with Vite plugin support. Write Node.js-style fs code that works in the browser!
@@ -14,7 +14,7 @@ Browser-compatible filesystem API with Vite plugin support. Write Node.js-style
 ## Installation
 ```bash
-npm install fs-browser
+npm install @jisan901/fs-browser
 ```
 ## Quick Start
@@ -26,7 +26,7 @@ npm install fs-browser
 ```javascript
 // vite.config.js
 import { defineConfig } from 'vite';
-import fsPlugin from 'fs-browser/plugin';
+import fsPlugin from '@jisan901/fs-browser/plugin';
 export default defineConfig({
   plugins: [
@@ -41,13 +41,13 @@ export default defineConfig({
 **2. Use in Browser Code**
 ```javascript
-import { readFile, writeFile, mkdir } from 'fs-browser';
+import { readFile, writeFile, mkdir } from '@jisan901/fs-browser';
 // Write a file
 await writeFile('hello.txt', 'Hello World!');
 // Read a file
-const content = await readFile('hello.txt');
+const content = await readFile('hello.txt', {encoding: 'utf-8'});
 console.log(content); // "Hello World!"
 // Create directory
@@ -115,7 +115,7 @@ withfs ./dist --host --open
 ## Development with Other Frameworks
-While `fs-browser` includes a Vite plugin, you can use it with any framework or development setup by running the `withfs` server separately.
+While `@jisan901/fs-browser` includes a Vite plugin, you can use it with any framework or development setup by running the `withfs` server separately.
 ### React (Create React App, Next.js)
@@ -138,7 +138,7 @@ npm start
 ```javascript
 // App.js
-import { readFile, writeFile } from 'fs-browser';
+import { readFile, writeFile } from '@jisan901/fs-browser';
 function App() {
   const handleSave = async () => {
@@ -153,7 +153,7 @@ function App() {
 ```javascript
 // lib/fs.js
-import fs from 'fs-browser';
+import fs from '@jisan901/fs-browser';
 export default fs.configure({
   apiBase: 'http://localhost:5001/api/fs'
@@ -202,7 +202,7 @@ npm run serve
 ```vue
 <!-- App.vue -->
 <script setup>
-import { readFile, writeFile } from 'fs-browser';
+import { readFile, writeFile } from '@jisan901/fs-browser';
 const saveFile = async () => {
   await writeFile('vue-data.json', { framework: 'Vue' });
@@ -218,7 +218,7 @@ const saveFile = async () => {
 ```javascript
 // composables/useFs.js
-import fs from 'fs-browser';
+import fs from '@jisan901/fs-browser';
 export const useFs = () => {
   return fs.configure({
@@ -274,7 +274,7 @@ ng serve
 ```typescript
 // app.component.ts
-import { readFile, writeFile } from 'fs-browser';
+import { readFile, writeFile } from '@jisan901/fs-browser';
 export class AppComponent {
   async saveFile() {
@@ -315,7 +315,7 @@ npm run dev
 ```svelte
 <!-- +page.svelte -->
 <script>
-  import { readFile, writeFile } from 'fs-browser';
+  import { readFile, writeFile } from '@jisan901/fs-browser';
   async function saveFile() {
     await writeFile('svelte-data.txt', 'Hello SvelteKit!');
@@ -360,7 +360,7 @@ npm run dev
 // src/pages/index.astro
 ---
 <script>
-  import { writeFile } from 'fs-browser';
+  import { writeFile } from '@jisan901/fs-browser';
   document.querySelector('#save')?.addEventListener('click', async () => {
     await writeFile('astro-data.json', { framework: 'Astro' });
@@ -378,7 +378,7 @@ npm run dev
 <!DOCTYPE html>
 <html>
 <head>
-  <title>fs-browser Demo</title>
+  <title>@jisan901/fs-browser Demo</title>
 </head>
 <body>
   <button id="save">Save File</button>
@@ -386,7 +386,7 @@ npm run dev
   <pre id="output"></pre>
   <script type="module">
-    import fs from 'https://cdn.jsdelivr.net/npm/fs-browser/src/index.js';
+    import fs from 'https://cdn.jsdelivr.net/npm/@jisan901/fs-browser/src/index.js';
     // Configure to point to your fs server
     const myFs = fs.configure({
@@ -399,7 +399,7 @@ npm run dev
     };
     document.getElementById('read').onclick = async () => {
-      const content = await myFs.readFile('demo.txt');
+      const content = await myFs.readFile('demo.txt', {encoding: 'utf-8'});
       document.getElementById('output').textContent = content;
     };
   </script>
@@ -448,7 +448,7 @@ npx parcel index.html
 ```javascript
 // Configure in your JS
-import { configure } from 'fs-browser';
+import { configure } from '@jisan901/fs-browser';
 configure({ apiBase: 'http://localhost:5001/api/fs' });
 ```
@@ -493,7 +493,7 @@ Set API base via environment variables:
 ```javascript
 // config/fs.js
-import fs from 'fs-browser';
+import fs from '@jisan901/fs-browser';
 const API_BASE = import.meta.env.VITE_FS_API_BASE ||
                  process.env.REACT_APP_FS_API_BASE ||
@@ -517,8 +517,8 @@ FROM node:18
 WORKDIR /app
-# Install fs-browser globally
-RUN npm install -g fs-browser
+# Install @jisan901/fs-browser globally
+RUN npm install -g @jisan901/fs-browser
 # Copy your built frontend
 COPY ./dist ./dist
@@ -584,7 +584,7 @@ services:
 Full TypeScript definitions included:
 ```typescript
-import { readFile, writeFile, Stats, Dirent } from 'fs-browser';
+import { readFile, writeFile, Stats, Dirent } from '@jisan901/fs-browser';
 const content: string = await readFile('test.txt', 'utf8');
 const stats: Stats = await stat('test.txt');

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "@jisan901/fs-browser",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Browser-compatible filesystem API with Vite plugin support",
     "main": "src/index.js",
     "types": "src/index.d.ts",

package/plugin/fs-handlers.js CHANGED Viewed

@@ -2,418 +2,527 @@
  * Shared FS API handlers for both Vite plugin and withfs CLI
  */
-import fs from 'fs/promises';
-import path from 'path';
+import fs from "fs/promises";
+import path from "path";
 /**
  * Helper to read raw body from request
  */
-export const getRawBody = (req) => {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on('data', (chunk) => chunks.push(chunk));
-    req.on('end', () => resolve(Buffer.concat(chunks)));
-    req.on('error', reject);
-  });
+export const getRawBody = req => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", chunk => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
 };
 /**
  * Helper to parse query string
  */
-export const parseQuery = (url) => {
-  const queryString = url.split('?')[1];
-  if (!queryString) return {};
-  return Object.fromEntries(new URLSearchParams(queryString));
+export const parseQuery = url => {
+    const queryString = url.split("?")[1];
+    if (!queryString) return {};
+    return Object.fromEntries(new URLSearchParams(queryString));
 };
 /**
  * Create path resolver with base directory restriction
  */
-export const createPathResolver = (baseDir) => {
-  return (filePath) => {
-    // Remove leading slash to treat all paths as relative
-    const normalizedPath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
-    const resolved = path.resolve(baseDir, normalizedPath);
-    if (!resolved.startsWith(baseDir)) {
-      throw new Error('Invalid path: outside base directory');
-    }
-    return resolved;
-  };
+export const createPathResolver = baseDir => {
+    return filePath => {
+        // Remove leading slash to treat all paths as relative
+        const normalizedPath = filePath.startsWith("/")
+            ? filePath.slice(1)
+            : filePath;
+        const resolved = path.resolve(baseDir, normalizedPath);
+        if (!resolved.startsWith(baseDir)) {
+            throw new Error("Invalid path: outside base directory");
+        }
+        return resolved;
+    };
 };
 /**
  * Create FS API handlers
  * @param {string} baseDir - Base directory for file operations
  * @returns {Object} - Handler functions mapped by route key
  */
-export const createFsHandlers = (baseDir) => {
-  const resolvePath = createPathResolver(baseDir);
-  return {
-    // Root endpoint
-    'GET /': async (req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        message: 'fs-browser API',
-        baseDirectory: baseDir
-      }));
-    },
-    // List all methods
-    'GET /methods': async (req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        methods: [
-          'readFile', 'writeFile', 'appendFile', 'copyFile',
-          'readdir', 'mkdir', 'rmdir', 'rm',
-          'rename', 'unlink',
-          'stat', 'lstat', 'readlink', 'realpath'
-        ]
-      }));
-    },
-    // Read file
-    'GET /readFile': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: filePath, encoding = 'utf8' } = query;
-      const fullPath = resolvePath(filePath);
-      const data = await fs.readFile(fullPath, encoding);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ data }));
-    },
-    // Read directory
-    'GET /readdir': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: dirPath = '.', withFileTypes = 'false' } = query;
-      const fullPath = resolvePath(dirPath);
-      const files = await fs.readdir(fullPath, {
-        withFileTypes: withFileTypes === 'true'
-      });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ files }));
-    },
-    // Get file stats
-    'GET /stat': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: filePath } = query;
-      const fullPath = resolvePath(filePath);
-      const stats = await fs.stat(fullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        stats: {
-          isFile: stats.isFile(),
-          isDirectory: stats.isDirectory(),
-          isSymbolicLink: stats.isSymbolicLink(),
-          size: stats.size,
-          mode: stats.mode,
-          mtime: stats.mtime,
-          atime: stats.atime,
-          ctime: stats.ctime,
-          birthtime: stats.birthtime
-        }
-      }));
-    },
-    // Get file stats (no symlink follow)
-    'GET /lstat': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: filePath } = query;
-      const fullPath = resolvePath(filePath);
-      const stats = await fs.lstat(fullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        stats: {
-          isFile: stats.isFile(),
-          isDirectory: stats.isDirectory(),
-          isSymbolicLink: stats.isSymbolicLink(),
-          size: stats.size,
-          mode: stats.mode,
-          mtime: stats.mtime,
-          atime: stats.atime,
-          ctime: stats.ctime,
-          birthtime: stats.birthtime
-        }
-      }));
-    },
-    // Get real path
-    'GET /realpath': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: filePath } = query;
-      const fullPath = resolvePath(filePath);
-      const realPath = await fs.realpath(fullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ realPath }));
-    },
-    // Read symlink
-    'GET /readlink': async (req, res) => {
-      const query = parseQuery(req.url);
-      const { path: linkPath } = query;
-      const fullPath = resolvePath(linkPath);
-      const target = await fs.readlink(fullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ target }));
-    },
-    // Write file
-    'POST /writeFile': async (req, res) => {
-      const contentType = req.headers['content-type'] || '';
-      const query = parseQuery(req.url);
-      let filePath = query.path;
-      let writeData;
-      let type;
-      const rawBody = await getRawBody(req);
-      // Handle binary content types
-      if (contentType.includes('application/octet-stream') ||
-          contentType.includes('image/') ||
-          contentType.includes('video/') ||
-          contentType.includes('audio/') ||
-          contentType.includes('application/pdf')) {
-        writeData = rawBody;
-        type = 'binary';
-      }
-      // Handle plain text
-      else if (contentType.includes('text/plain')) {
-        writeData = rawBody;
-        type = 'text';
-      }
-      // Handle JSON
-      else if (contentType.includes('application/json')) {
-        // If path is in query string, treat rawBody as the content to write
-        if (filePath) {
-          writeData = rawBody;
-          type = 'json';
-        }
-        // Otherwise, parse as structured request body
-        else {
-          if (rawBody.length === 0) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Empty request body' }));
-            return;
-          }
-          const body = JSON.parse(rawBody.toString());
-          filePath = body.path;
-          if (!filePath) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Path is required' }));
-            return;
-          }
-          const { data, type: dataType = 'text', encoding = 'utf8' } = body;
-          if (data === undefined || data === null) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Data is required' }));
-            return;
-          }
-          type = dataType;
-          switch (dataType) {
-            case 'text':
-              writeData = Buffer.from(String(data), encoding);
-              break;
-            case 'json':
-              writeData = Buffer.from(JSON.stringify(data, null, 2), encoding);
-              break;
-            case 'buffer':
-              writeData = Array.isArray(data) ? Buffer.from(data) : Buffer.from(data, 'base64');
-              break;
-            default:
-              writeData = Buffer.from(String(data), encoding);
-          }
+export const createFsHandlers = baseDir => {
+    const resolvePath = createPathResolver(baseDir);
+    return {
+        // Root endpoint
+        "GET /": async (req, res) => {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "fs-browser API",
+                    baseDirectory: baseDir
+                })
+            );
+        },
+        // List all methods
+        "GET /methods": async (req, res) => {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    methods: [
+                        "readFile",
+                        "writeFile",
+                        "appendFile",
+                        "copyFile",
+                        "readdir",
+                        "mkdir",
+                        "rmdir",
+                        "rm",
+                        "rename",
+                        "unlink",
+                        "stat",
+                        "lstat",
+                        "readlink",
+                        "realpath"
+                    ]
+                })
+            );
+        },
+        // Read file
+        "GET /readFile": async (req, res) => {
+            try {
+                const query = parseQuery(req.url);
+                const { path: filePath, encoding } = query;
+                const fullPath = resolvePath(filePath);
+                const contentType = encoding ? "text/plain" : "application/octet-stream";
+                // 2. Reading file WITHOUT an encoding (returns a Buffer/binary)
+                let options = {}
+                if (encoding) {options.encoding = encoding || 'utf8';}
+                const data = await fs.readFile(fullPath, options );
+                // 3. Write the headers and send the data
+                res.writeHead(200, { "Content-Type": contentType });
+                res.end(data);
+            } catch (err) {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("File not found or error reading file");
+            }
+        },
+        // Read directory
+        "GET /readdir": async (req, res) => {
+            const query = parseQuery(req.url);
+            const { path: dirPath = ".", withFileTypes = "false" } = query;
+            const fullPath = resolvePath(dirPath);
+            const files = await fs.readdir(fullPath, {
+                withFileTypes: withFileTypes === "true"
+            });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ files }));
+        },
+        // Get file stats
+        "GET /stat": async (req, res) => {
+            const query = parseQuery(req.url);
+            const { path: filePath } = query;
+            const fullPath = resolvePath(filePath);
+            const stats = await fs.stat(fullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    stats: {
+                        isFile: stats.isFile(),
+                        isDirectory: stats.isDirectory(),
+                        isSymbolicLink: stats.isSymbolicLink(),
+                        size: stats.size,
+                        mode: stats.mode,
+                        mtime: stats.mtime,
+                        atime: stats.atime,
+                        ctime: stats.ctime,
+                        birthtime: stats.birthtime
+                    }
+                })
+            );
+        },
+        // Get file stats (no symlink follow)
+        "GET /lstat": async (req, res) => {
+            const query = parseQuery(req.url);
+            const { path: filePath } = query;
+            const fullPath = resolvePath(filePath);
+            const stats = await fs.lstat(fullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    stats: {
+                        isFile: stats.isFile(),
+                        isDirectory: stats.isDirectory(),
+                        isSymbolicLink: stats.isSymbolicLink(),
+                        size: stats.size,
+                        mode: stats.mode,
+                        mtime: stats.mtime,
+                        atime: stats.atime,
+                        ctime: stats.ctime,
+                        birthtime: stats.birthtime
+                    }
+                })
+            );
+        },
+        // Get real path
+        "GET /realpath": async (req, res) => {
+            const query = parseQuery(req.url);
+            const { path: filePath } = query;
+            const fullPath = resolvePath(filePath);
+            const realPath = await fs.realpath(fullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ realPath }));
+        },
+        // Read symlink
+        "GET /readlink": async (req, res) => {
+            const query = parseQuery(req.url);
+            const { path: linkPath } = query;
+            const fullPath = resolvePath(linkPath);
+            const target = await fs.readlink(fullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ target }));
+        },
+        // Write file
+        "POST /writeFile": async (req, res) => {
+            const contentType = req.headers["content-type"] || "";
+            const query = parseQuery(req.url);
+            let filePath = query.path;
+            let writeData;
+            let type;
+            const rawBody = await getRawBody(req);
+            // Handle binary content types
+            if (
+                contentType.includes("application/octet-stream") ||
+                contentType.includes("image/") ||
+                contentType.includes("video/") ||
+                contentType.includes("audio/") ||
+                contentType.includes("application/pdf")
+            ) {
+                writeData = rawBody;
+                type = "binary";
+            }
+            // Handle plain text
+            else if (contentType.includes("text/plain")) {
+                writeData = rawBody;
+                type = "text";
+            }
+            // Handle JSON
+            else if (contentType.includes("application/json")) {
+                // If path is in query string, treat rawBody as the content to write
+                if (filePath) {
+                    writeData = rawBody;
+                    type = "json";
+                }
+                // Otherwise, parse as structured request body
+                else {
+                    if (rawBody.length === 0) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(
+                            JSON.stringify({ error: "Empty request body" })
+                        );
+                        return;
+                    }
+                    const body = JSON.parse(rawBody.toString());
+                    filePath = body.path;
+                    if (!filePath) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(JSON.stringify({ error: "Path is required" }));
+                        return;
+                    }
+                    const {
+                        data,
+                        type: dataType = "text",
+                        encoding = "utf8"
+                    } = body;
+                    if (data === undefined || data === null) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(JSON.stringify({ error: "Data is required" }));
+                        return;
+                    }
+                    type = dataType;
+                    switch (dataType) {
+                        case "text":
+                            writeData = Buffer.from(String(data), encoding);
+                            break;
+                        case "json":
+                            writeData = Buffer.from(
+                                JSON.stringify(data, null, 2),
+                                encoding
+                            );
+                            break;
+                        case "buffer":
+                            writeData = Array.isArray(data)
+                                ? Buffer.from(data)
+                                : Buffer.from(data, "base64");
+                            break;
+                        default:
+                            writeData = Buffer.from(String(data), encoding);
+                    }
+                }
+            }
+            // Fallback for unknown content types
+            else {
+                writeData = rawBody;
+                type = "unknown";
+            }
+            // Validate we have data to write
+            if (!writeData || writeData.length === 0) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No data to write" }));
+                return;
+            }
+            const fullPath = resolvePath(filePath);
+            await fs.writeFile(fullPath, writeData);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "File written successfully",
+                    path: filePath,
+                    type,
+                    size: writeData.length
+                })
+            );
+        },
+        // Append file
+        "POST /appendFile": async (req, res) => {
+            const contentType = req.headers["content-type"] || "";
+            const query = parseQuery(req.url);
+            let filePath = query.path;
+            let appendData;
+            let type;
+            const rawBody = await getRawBody(req);
+            // Handle binary content types
+            if (
+                contentType.includes("application/octet-stream") ||
+                contentType.includes("image/") ||
+                contentType.includes("video/") ||
+                contentType.includes("audio/") ||
+                contentType.includes("application/pdf")
+            ) {
+                appendData = rawBody;
+                type = "binary";
+            }
+            // Handle plain text
+            else if (contentType.includes("text/plain")) {
+                appendData = rawBody;
+                type = "text";
+            }
+            // Handle JSON
+            else if (contentType.includes("application/json")) {
+                // If path is in query string, treat rawBody as the content to append
+                if (filePath) {
+                    appendData = rawBody;
+                    type = "json";
+                }
+                // Otherwise, parse as structured request body
+                else {
+                    if (rawBody.length === 0) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(
+                            JSON.stringify({ error: "Empty request body" })
+                        );
+                        return;
+                    }
+                    const body = JSON.parse(rawBody.toString());
+                    filePath = body.path;
+                    if (!filePath) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(JSON.stringify({ error: "Path is required" }));
+                        return;
+                    }
+                    const {
+                        data,
+                        type: dataType = "text",
+                        encoding = "utf8"
+                    } = body;
+                    if (data === undefined || data === null) {
+                        res.writeHead(400, {
+                            "Content-Type": "application/json"
+                        });
+                        res.end(JSON.stringify({ error: "Data is required" }));
+                        return;
+                    }
+                    type = dataType;
+                    switch (dataType) {
+                        case "text":
+                            appendData = Buffer.from(String(data), encoding);
+                            break;
+                        case "json":
+                            appendData = Buffer.from(
+                                JSON.stringify(data, null, 2),
+                                encoding
+                            );
+                            break;
+                        case "buffer":
+                            appendData = Array.isArray(data)
+                                ? Buffer.from(data)
+                                : Buffer.from(data, "base64");
+                            break;
+                        default:
+                            appendData = Buffer.from(String(data), encoding);
+                    }
+                }
+            }
+            // Fallback
+            else {
+                appendData = rawBody;
+                type = "unknown";
+            }
+            // Validate we have data
+            if (!appendData || appendData.length === 0) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No data to append" }));
+                return;
+            }
+            const fullPath = resolvePath(filePath);
+            await fs.appendFile(fullPath, appendData);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "Data appended successfully",
+                    path: filePath,
+                    type,
+                    size: appendData.length
+                })
+            );
+        },
+        // Copy file
+        "POST /copyFile": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const { src, dest, flags = 0 } = JSON.parse(rawBody.toString());
+            const srcPath = resolvePath(src);
+            const destPath = resolvePath(dest);
+            await fs.copyFile(srcPath, destPath, flags);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "File copied successfully",
+                    src,
+                    dest
+                })
+            );
+        },
+        // Create directory
+        "POST /mkdir": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const { path: dirPath, recursive = true } = JSON.parse(
+                rawBody.toString()
+            );
+            const fullPath = resolvePath(dirPath);
+            await fs.mkdir(fullPath, { recursive });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({ message: "Directory created", path: dirPath })
+            );
+        },
+        // Remove directory
+        "DELETE /rmdir": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const { path: dirPath, recursive = false } = JSON.parse(
+                rawBody.toString()
+            );
+            const fullPath = resolvePath(dirPath);
+            await fs.rmdir(fullPath, { recursive });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({ message: "Directory removed", path: dirPath })
+            );
+        },
+        // Remove file or directory
+        "DELETE /rm": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const {
+                path: targetPath,
+                recursive = false,
+                force = false
+            } = JSON.parse(rawBody.toString());
+            const fullPath = resolvePath(targetPath);
+            await fs.rm(fullPath, { recursive, force });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "Removed successfully",
+                    path: targetPath
+                })
+            );
+        },
+        // Rename
+        "PUT /rename": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const { oldPath, newPath } = JSON.parse(rawBody.toString());
+            const oldFullPath = resolvePath(oldPath);
+            const newFullPath = resolvePath(newPath);
+            await fs.rename(oldFullPath, newFullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({
+                    message: "Renamed successfully",
+                    oldPath,
+                    newPath
+                })
+            );
+        },
+        // Delete file
+        "DELETE /unlink": async (req, res) => {
+            const rawBody = await getRawBody(req);
+            const { path: filePath } = JSON.parse(rawBody.toString());
+            const fullPath = resolvePath(filePath);
+            await fs.unlink(fullPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+                JSON.stringify({ message: "File deleted", path: filePath })
+            );
         }
-      }
-      // Fallback for unknown content types
-      else {
-        writeData = rawBody;
-        type = 'unknown';
-      }
-      // Validate we have data to write
-      if (!writeData || writeData.length === 0) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'No data to write' }));
-        return;
-      }
-      const fullPath = resolvePath(filePath);
-      await fs.writeFile(fullPath, writeData);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        message: 'File written successfully',
-        path: filePath,
-        type,
-        size: writeData.length
-      }));
-    },
-    // Append file
-    'POST /appendFile': async (req, res) => {
-      const contentType = req.headers['content-type'] || '';
-      const query = parseQuery(req.url);
-      let filePath = query.path;
-      let appendData;
-      let type;
-      const rawBody = await getRawBody(req);
-      // Handle binary content types
-      if (contentType.includes('application/octet-stream') ||
-          contentType.includes('image/') ||
-          contentType.includes('video/') ||
-          contentType.includes('audio/') ||
-          contentType.includes('application/pdf')) {
-        appendData = rawBody;
-        type = 'binary';
-      }
-      // Handle plain text
-      else if (contentType.includes('text/plain')) {
-        appendData = rawBody;
-        type = 'text';
-      }
-      // Handle JSON
-      else if (contentType.includes('application/json')) {
-        // If path is in query string, treat rawBody as the content to append
-        if (filePath) {
-          appendData = rawBody;
-          type = 'json';
-        }
-        // Otherwise, parse as structured request body
-        else {
-          if (rawBody.length === 0) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Empty request body' }));
-            return;
-          }
-          const body = JSON.parse(rawBody.toString());
-          filePath = body.path;
-          if (!filePath) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Path is required' }));
-            return;
-          }
-          const { data, type: dataType = 'text', encoding = 'utf8' } = body;
-          if (data === undefined || data === null) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Data is required' }));
-            return;
-          }
-          type = dataType;
-          switch (dataType) {
-            case 'text':
-              appendData = Buffer.from(String(data), encoding);
-              break;
-            case 'json':
-              appendData = Buffer.from(JSON.stringify(data, null, 2), encoding);
-              break;
-            case 'buffer':
-              appendData = Array.isArray(data) ? Buffer.from(data) : Buffer.from(data, 'base64');
-              break;
-            default:
-              appendData = Buffer.from(String(data), encoding);
-          }
-        }
-      }
-      // Fallback
-      else {
-        appendData = rawBody;
-        type = 'unknown';
-      }
-      // Validate we have data
-      if (!appendData || appendData.length === 0) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'No data to append' }));
-        return;
-      }
-      const fullPath = resolvePath(filePath);
-      await fs.appendFile(fullPath, appendData);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        message: 'Data appended successfully',
-        path: filePath,
-        type,
-        size: appendData.length
-      }));
-    },
-    // Copy file
-    'POST /copyFile': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { src, dest, flags = 0 } = JSON.parse(rawBody.toString());
-      const srcPath = resolvePath(src);
-      const destPath = resolvePath(dest);
-      await fs.copyFile(srcPath, destPath, flags);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'File copied successfully', src, dest }));
-    },
-    // Create directory
-    'POST /mkdir': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { path: dirPath, recursive = true } = JSON.parse(rawBody.toString());
-      const fullPath = resolvePath(dirPath);
-      await fs.mkdir(fullPath, { recursive });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'Directory created', path: dirPath }));
-    },
-    // Remove directory
-    'DELETE /rmdir': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { path: dirPath, recursive = false } = JSON.parse(rawBody.toString());
-      const fullPath = resolvePath(dirPath);
-      await fs.rmdir(fullPath, { recursive });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'Directory removed', path: dirPath }));
-    },
-    // Remove file or directory
-    'DELETE /rm': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { path: targetPath, recursive = false, force = false } = JSON.parse(rawBody.toString());
-      const fullPath = resolvePath(targetPath);
-      await fs.rm(fullPath, { recursive, force });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'Removed successfully', path: targetPath }));
-    },
-    // Rename
-    'PUT /rename': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { oldPath, newPath } = JSON.parse(rawBody.toString());
-      const oldFullPath = resolvePath(oldPath);
-      const newFullPath = resolvePath(newPath);
-      await fs.rename(oldFullPath, newFullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'Renamed successfully', oldPath, newPath }));
-    },
-    // Delete file
-    'DELETE /unlink': async (req, res) => {
-      const rawBody = await getRawBody(req);
-      const { path: filePath } = JSON.parse(rawBody.toString());
-      const fullPath = resolvePath(filePath);
-      await fs.unlink(fullPath);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ message: 'File deleted', path: filePath }));
-    }
-  };
-};
+    };
+};

package/src/index.js CHANGED Viewed

@@ -46,8 +46,8 @@ export function configure(options = {}) {
  * @param {string|Object} options - Encoding string or options object
  * @returns {Promise<string|Buffer>}
  */
-export async function readFile(path, options = 'utf8') {
-  const encoding = typeof options === 'string' ? options : options?.encoding || 'utf8';
+export async function readFile(path, options = '') {
+  const encoding = typeof options === 'string' ? options : options?.encoding || '';
   const response = await fetch(`${API_BASE}/readFile?path=${encodeURIComponent(path)}&encoding=${encoding}`);
   if (!response.ok) {
@@ -55,8 +55,17 @@ export async function readFile(path, options = 'utf8') {
     throw new Error(error.error?.message || 'Failed to read file');
   }
-  const { data } = await response.json();
-  return data;
+  const contentType = response.headers.get("content-type");
+    if (contentType?.includes("text/plain")) {
+        const data = await response.text();
+        return data;
+    } else {
+        const buffer = await response.arrayBuffer();
+        return buffer;
+    }
+    return response;
 }
 /**