@valentinkolb/filegate 0.0.5 → 0.0.6

package/README.md

@@ -1,6 +1,6 @@
 # Filegate
 
-A secure file proxy server for building custom file management systems. Bring your own backend and frontend - Filegate handles the file operations.
+Secure file proxy for building custom file management systems. Streaming uploads, chunked transfers, Unix permissions.
 
 ```
 Browser/App          Your Backend            Filegate            Filesystem
@@ -16,7 +16,7 @@ Browser/App          Your Backend            Filegate            Filesystem
      |<-------------------|                     |                    |
 ```
 
-Filegate is designed to work behind your backend, not as a public-facing service. Your backend handles authentication and authorization, then proxies requests to Filegate. This gives you full control over access logic while Filegate handles the complexity of streaming, chunked uploads, permissions, and security.
+Filegate runs behind your backend, not as a public-facing service. Your backend handles authentication and authorization, then proxies requests to Filegate. You control access logic - Filegate handles file operations.
 
 ## Features
 
@@ -27,6 +27,7 @@ Filegate is designed to work behind your backend, not as a public-facing service
 - Glob-based file search
 - Type-safe client with full TypeScript support
 - OpenAPI documentation
+- Minimal dependencies (Hono, Zod - no database required)
 
 ## Quick Start
 
@@ -83,34 +84,6 @@ if (result.ok) {
 }
 ```
 
-## Architecture
-
-Filegate follows a proxy architecture where your backend mediates all file operations:
-
-```
-+------------------+       +------------------+       +------------------+
-|                  |       |                  |       |                  |
-|   Your Client    |<----->|   Your Backend   |<----->|    Filegate      |
-|   (Browser/App)  |       |   (Auth, Logic)  |       |   (File Ops)     |
-|                  |       |                  |       |                  |
-+------------------+       +------------------+       +------------------+
-                                                              |
-                                                              v
-                                                      +------------------+
-                                                      |                  |
-                                                      |   Filesystem     |
-                                                      |                  |
-                                                      +------------------+
-```
-
-**Your Client** handles the UI and user interactions. It communicates with your backend.
-
-**Your Backend** handles authentication, authorization, and business logic. It decides who can access what and proxies requests to Filegate.
-
-**Filegate** handles the actual file operations: reading, writing, streaming, chunked uploads, permissions. It only accepts requests with a valid token.
-
-This separation means you have full control over access patterns while Filegate handles the complexity of file operations.
-
 ## Core Concepts
 
 ### Base Paths
@@ -131,7 +104,7 @@ Symlinks that point outside base paths are also blocked.
 
 ### File Ownership
 
-Filegate runs as root to set file ownership. When uploading files, you can specify Unix permissions:
+Filegate can set Unix file ownership on uploaded files:
 
 ```typescript
 await client.upload.single({
@@ -144,7 +117,11 @@ await client.upload.single({
 });
 ```
 
-This is essential when Filegate manages files for multiple users on a shared filesystem.
+If ownership is not specified, files are created with the user running Filegate (typically root in Docker).
+
+Filegate does not validate whether the specified uid/gid exists on the system, nor does it verify that the requesting user matches the specified ownership. Your backend is responsible for this validation.
+
+This feature is intended for scenarios like NFS shares exposed through Filegate, where preserving the original permission structure is required.
 
 ### Chunked Uploads
 
@@ -154,6 +131,8 @@ For large files, use chunked uploads. They support:
 - Per-chunk checksum verification
 - Automatic assembly when complete
 
+The [Browser Utilities](#browser-utilities) help with checksum calculation, chunking, and progress tracking. They work both in the browser and on the server.
+
 ```typescript
 // Start or resume upload
 const start = await client.upload.chunked.start({
@@ -325,7 +304,7 @@ if (result.ok) {
 
 ## Browser Utilities
 
-For browser-based chunked uploads, use the utils package:
+Utilities for chunked uploads that work both in the browser and on the server. They handle file chunking, SHA-256 checksum calculation, progress tracking, and retry logic.
 
 ```typescript
 import { chunks, formatBytes } from "@valentinkolb/filegate/utils";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valentinkolb/filegate",
-  "version": "0.0.5",
-  "description": "Secure, high-performance file proxy server with streaming uploads, chunked uploads, and TAR downloads",
+  "version": "0.0.6",
+  "description": "Secure file proxy for building custom file management systems. Streaming uploads, chunked transfers, Unix permissions.",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
 import { Scalar } from "@scalar/hono-api-reference";
 import { generateSpecs } from "hono-openapi";
 import { createMarkdownFromOpenApi } from "@scalar/openapi-to-markdown";
@@ -69,6 +70,11 @@ app.notFound((c) => c.json({ error: "not found" }, 404));
 
 // Error handler
 app.onError((err, c) => {
+  // HTTPException (from bearerAuth, etc.) - return the proper response
+  if (err instanceof HTTPException) {
+    return err.getResponse();
+  }
+
   console.error("[Filegate] Error:", err);
   return c.json({ error: "internal error" }, 500);
 });