ReboFilesDocs
Start3
What is ReboFiles
Getting started
Demos to run
Put it in your app6
React component
Headless: your own UI
Without a framework
Styling and themes
Keyboard and accessibility
Languages
Files9
Uploads
Previews and the viewer
Search
Live changes and large folders
Comments
Starred and fields
Versions, trash and space
Download as .zip
Word documents
The server14
The route
Frameworks and sign-in
Who may do what
Storage: S3, GCS, Azure and disk
Checking uploads
Metadata: SQLite and Postgres
Database schema
Sharing and links
Activity and notifications
Hooks, logs and limits
Retention, holds and export
Desktop and other origins
Sync a folder
Going to production
Together1
AI assistants (MCP)
Reference5
Packages
Components and hooks
Client API
HTTP routes
Status and roadmap
↑↓ to move↵ to openEsc to close38 pages

Reference Status and roadmap

Status and roadmap

Version 0.12.0, on npm. The numbers are what running the commands gave on October 28, 2026, not what anyone remembers; the same is in ROADMAP.md.
Tests

What is checked

404 tests, every one passing, by npm test and, in Chrome, npm run test:browser.

packages/core

72

Names, the tree, renaming and moving, the trash and the trash that empties itself, versions, search, changes; the top of the drive for each owner, roles down the tree, Shared with me and what is new in it, links with a password or a number of uses; settings, space, archives, activity, text found in a file, folder colours and placeholders; groups of the application, reached down the tree and in Shared with me. Requests for files read as given, and shares that end.

packages/server

159

The routes on the disk and on an S3 kept in memory, uploads in parts, resumed and given up, quotas, who may do what, sharing and links read without signing in, with a password or for one download, news of what is shared, the same file found again, settings, pictures in sizes, addresses good for an hour, the drive held in memory, activity and text on memory, SQLite and Postgres on PGlite, pages of another origin, and the signature against AWS’s example. Uploads refused before and after they arrive: by beforeUpload, by the type their bytes are, by a ClamAV that knows EICAR, and while it is down; uploads left halfway swept from a bucket and the disk. The events: each told only what they may see, from this process and from another on the same SQLite, and the client coming back after a cut. The drive a piece at a time: what SQLite and Postgres answer to each query is what the drive held whole answers; rows of before filled once; two hundred thousand entries listed in milliseconds, never read whole. Comments, threads, resolved, taken back; a legal hold and a minimum of days; everything of a person exported. onChange, the logger, OpenTelemetry, limits by person, by link and by address. Only the parts of a version that changed sent, the rest copied in the bucket and on the disk. Pictures, placeholders and text made by the server with sharp and pdf.js, a PDF’s first page among them. Copies of a file; requests for files sent signed out, looked at, and reminded of by email; the people and groups of a directory; webhooks signed and tried again; and `onRead` told who read what.

packages/drive

46

The client against the routes and against a bucket: uploads in parts with progress, resumed after a cut, the headers a bucket signed, versions, refusals; the queue of uploads, three at a time, its speed and time left, the same file or name asked about; folders of the computer read as they were; the .zip written and read back; the text of a file; the drive kept in the page; what the server refused, said in each language. A QR code drawn as SVG.

packages/react

18

The hooks in components, against the drive kept in the page: a folder, a search, Recent and the trash asked again after a change through useActions; a view loading as itself, not as the last; useEntry after a rename; settings and the language following them; uploads and their end; what someone else changed shown without asking; and <FileDrive> beside the hooks; and useComments. Starred and received, a copy, a colour, fields and a review through useActions; an entry’s activity, a search by what is written, notifications seen, requests for files and people looked up, what is about to expire and the files of one record, each in a hook of its own.

packages/sync

8

A folder of the disk and a drive behind its routes kept the same: what is made, changed, moved, renamed and taken away on each side, both changed as a conflict kept twice, a folder and a file of one name, the files of the systems left out, a disk found empty refused; and a sync that goes on, run by the drive’s events and by a file of the disk.

examples

5

Next.js, Express, Hono and Fastify, each served on a port and asked over HTTP: a folder, a file of two parts uploaded and read back, and the events of a change; and who asks from a JWT, a forged one refused.

packages/mcp

19

The protocol and every tool over HTTP and stdio, two people’s assistants each doing only what its person may; activity, a search by what is written, folder colours; Rebodocs’ tools on the drive’s Word documents, each change a version; and driven by the official SDK as a client.

apps/desktop

5

Which server the window is of, kept between starts and tried before it is taken; and in Rust (cargo test), a name taken in Downloads made free, a path of the folder synced that would leave it refused, and what is listed, moved and taken away there.

npm run test:browser

72

The playground in Chrome with Playwright: uploads in parts, several at once, stopped and resumed, folders dropped, the same file and the same name asked about; the preview and the viewer; .zip downloads; search by name and by what is written; sharing with Bea, links signed out, one with a password, what is new in Shared with me; the list in an order of one’s choosing, its menu, undo; settings and quotas; activity; folder colours and pictures shown blurred; the keyboard alone; axe on every state, light and dark; the drive with no framework and from the hooks alone; the demo’s Claude through the MCP tools; a folder made and renamed in one window seen in another without loading again; a folder of four hundred, of which only what is in sight is in the page, gone through with the keyboard and the grid; comments said, answered, edited and resolved, axe on them, seen in another window; a legal hold; a PDF’s first page made by the server and shown as it comes. All of it in WebKit too. A copy made from the menu; a share for a week, until when; requests for files sent signed out, with documents and photos, and looked at in Received; the drive without its own bar, driven by the application’s, and kept in a folder.

By hand

Checked by hand

Cloudflare R2

npm run storage:check from Node: a file in one PUT, one of 16 MiB in parts, each read back byte for byte, a second version, a download shown in the page, an upload given up, the deletion in one request, seen in the bucket. Then the page against the same bucket, with its rule of origins.

The interface

Driven in Chrome with real clicks and keys: a folder made, files uploaded into it, a text previewed, a second upload with the same name as “(2)”, renaming with F2, the trash with Delete and back, search, moving from the dialog, the grid, and the drive in Spanish at the width of a phone.

Postgres

Two pools on one Postgres 16, as two servers, making twenty folders of one name at once: twenty names, none given twice. Without the lock, ten.

The site

axe on the landing, Getting started and this page, at the width of a desktop and of a phone, with motion and with less of it: nothing found.

Rebodocs

A Word document uploaded, previewed as a page, opened in Rebodocs, changed, saved with ⌘S, and back in the drive as its second version.

The demo

Acme’s files made in the page, a Word document and a PDF previewed, Claude’s rename and its card, an upload in steps, the trash emptied.

Pictures

Against R2: a picture uploaded in four sizes and its placeholder, the grid reading the small ones from addresses good for an hour; a Word document’s first page made a picture at upload; a .zip of six files.

The desktop

ReboFiles.app built on a Mac with Tauri and started; its page against the playground from another origin, an upload in parts through it. Its sync of a folder built and its commands tested in Rust; not driven in the window yet.

The documentation

axe on each page of the documentation added on October 26, 2026, in English, Spanish and Mandarin, at the width of a desktop and of a phone: nothing found, nothing wider than the screen.

The builds

Each package built as it goes to npm and installed from its tarball in an empty project: a server on node:http, the client uploading and reading back over the network, <FileDrive> rendered on a server, a strict typecheck.

Not yet

What is not

Other buckets

Cloudflare R2 only. Not AWS, MinIO or Backblaze yet.

Other browsers

Chrome and WebKit (Safari’s engine) by the tests, all of them in each. Firefox in the workflow only: Playwright’s Firefox does not start on this Mac. Not on a real phone.

Two processes on SQLite

Opened by two handlers one after the other for changes; the events of one seen by the other. For more than one process that writes, Postgres.

Windows and Linux

The Desktop workflow builds and tests the application on both; it has not run yet, and nobody has used it there.

The workflows

CI, Desktop and Release are written; the first CI was pushed, and has not been looked at.

Limits

Known limits

Storage

  • An upload left halfway stays in the bucket as parts for a day, to be gone on with; after that the server sweeps it, as requests come.

Metadata

  • SQLite, Postgres and memory are asked a piece at a time; a store of one’s own without scoped is held whole in memory, fine for a team and well beyond, not for millions of entries.
  • Changes are put in order inside one process only, but on Postgres with a pool, where a lock of the database orders them across processes.
  • The changes of another process are seen by the events within two seconds, from the revision of the store.

Sync

  • A folder renamed on the disk is sent again as a new one; its old one goes to the trash.
  • A file goes whole each time, not the part of it that changed.
  • In the desktop application, the disk is looked at every half a minute and when the window comes to the front, not as each file changes.

Uploads

  • Files of up to 5 GiB unless maxSize says otherwise; an upload is good for a day.
  • The same file is told by a SHA-256 made in the page, up to 64 MiB; a larger one only by its name.
  • A PDF’s first page and its text are made by the server, with derive and pdf.js; without it, a PDF has no picture and is not found by its words.

Sharing

  • People and groups are named by the ids the application gives them; who is in a group is the application’s, asked as it identifies.
  • Links are for viewers only.
  • An editor who moves something of someone else’s to the top puts it in its owner’s My files.
Next

Roadmap

In the order it is built. Each version goes to npm when its last item is done, and not before.

  1. 0.1.0A drive that works6 of 7

    • core: the tree, names that do not repeat in a folder, moving, renaming, the trash, versions, search
    • server: the routes, authorize(), bytes on S3 and on disk, metadata in memory and SQLite, uploads in parts
    • react: <FileDrive> with the list and the grid, folders, search, upload, details, versions, the trash
    • Previews of pictures, PDF and DOCX; “Open in Rebodocs”
    • The demo, the playground, and the drive run against Cloudflare R2
    • The site: the landing, Getting started and this page
    • Published to npm (not yet)
  2. 0.2.0Sharing3 of 3

    • Owner, editor, commenter and viewer, inherited down the tree; “Shared with me”
    • Links with an expiry, signed by the server
    • Metadata on Postgres
  3. 0.3.0Your own UI3 of 3

    • @rebofiles/drive split out of react, without a framework
    • The headless hooks, documented with a whole screen built from them
    • Accessible: every action from the keyboard, screen readers, axe, a dark theme; Playwright
  4. 0.4.0Assistants3 of 3

    • @rebofiles/mcp, with authorize() asked for the assistant too
    • Claude in the demo: its calls to the MCP tools, answered in the page
    • Rebodocs’ MCP and ReboFiles’ together: the drive’s Word documents edited, each change a version
  5. 0.5.0Big files and other storage1 of 2

    • Uploads that resume after a cut, files of several gigabytes
    • Google Cloud Storage and Azure Blob (not yet)
  6. 0.6.0The desktop2 of 2

    • @rebofiles/sync: a folder of the disk kept like a folder of the drive, in the window and as a command
    • The Tauri application, on a Mac first: the drive in a window, against a server
  7. 1.0.0Settled

    • Used in a real application, and fixed where that shows (not yet)
    • The API settled, and kept from then on (not yet)
MIT

License

MIT. Anyone may use it for anything, including commercially, with no warranty.