@telecrypt-io/storage 0.2.3 → 0.2.5

package/README.md

@@ -8,14 +8,14 @@ Files are encrypted on the client before upload. The server stores only opaque c
 never holds the decryption keys. Shared folders let multiple people add and read files, and a
 Recovery Key restores your files on a new device — even if you lose the original.
 
-**Status:** library source only. `@telecrypt-io/storage@0.2.3` is the current public release,
-published from this repository's protected `v0.2.3` tag with NPM Trusted Publishing/OIDC
+**Status:** library source only. `@telecrypt-io/storage@0.2.5` is the current public release,
+published from this repository's protected `v0.2.5` tag with NPM Trusted Publishing/OIDC
 provenance. The older `0.1.3` release is the immutable legacy combined library-and-CLI package.
 
 ## Install
 
 ```bash
-npm install @telecrypt-io/storage@0.2.3
+npm install @telecrypt-io/storage@0.2.5
 ```
 
 This gives you the `TeleCryptIOStorage` library and its browser-safe `core` API.

package/dist/core/operations.js

@@ -1,5 +1,47 @@
 import { CliError } from "./errors.js";
 import { waitForCondition } from "./poll.js";
+/**
+ * Production Synapse enforces the built-in rc_messages budget (per-account
+ * burst 10, refill 1/5s) on every room/state mutation the tree operations
+ * issue. A delete/decline sequence (kick members + leave + forget) can
+ * exceed the burst within seconds, so each operation retries on 429 with the
+ * server-advised backoff. Mirrors the harness library suite's
+ * `withRateLimitRetry`; must not mask non-rate-limit failures.
+ */
+const RATE_LIMIT_RETRIES = 6;
+function isRateLimited(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!("isRateLimitError" in error))
+        return false;
+    const isRateLimitError = error.isRateLimitError;
+    return typeof isRateLimitError === "function" && isRateLimitError.call(error) === true;
+}
+async function withRateLimitRetry(label, operation) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (!isRateLimited(error) || attempt >= RATE_LIMIT_RETRIES)
+                throw error;
+            // The server's retry_after_ms only covers one token; tree operations
+            // need several (kick + leave + forget). Wait at least 15s so the
+            // burst refills.
+            let retryAfter = 15_000;
+            if (error instanceof Error && "getRetryAfterMs" in error) {
+                const getRetryAfterMs = error.getRetryAfterMs;
+                if (typeof getRetryAfterMs === "function") {
+                    const advised = getRetryAfterMs.call(error);
+                    if (typeof advised === "number" && Number.isFinite(advised) && advised > 0) {
+                        retryAfter = Math.max(retryAfter, advised);
+                    }
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, retryAfter));
+        }
+    }
+}
 /**
  * Resolves a folder by ID, polling briefly: a room this same account just
  * created (or was just invited to, by another process/session) can be
@@ -32,7 +74,7 @@ function toArrayBuffer(bytes) {
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
 export async function createFolder(storage, name) {
-    const tree = await storage.createTree(name);
+    const tree = await withRateLimitRetry("createFolder", () => storage.createTree(name));
     return { id: tree.id, name };
 }
 /** Top-level folders only — excludes subdirectories of an existing tree. */
@@ -102,13 +144,15 @@ export async function listPendingInvites(storage) {
 export async function declineInvite(storage, folderId) {
     const client = storage.getClient();
     try {
-        await client.leave(folderId);
-        // The server only allows forgetting a room once this account's
-        // membership is `leave`; forgetting removes the room from the local
-        // store immediately, so a declined invite stops showing up in
-        // listFolders/listPendingInvites without waiting for the leave event to
-        // round-trip through the background sync loop.
-        await client.forget(folderId);
+        await withRateLimitRetry("declineInvite", async () => {
+            await client.leave(folderId);
+            // The server only allows forgetting a room once this account's
+            // membership is `leave`; forgetting removes the room from the local
+            // store immediately, so a declined invite stops showing up in
+            // listFolders/listPendingInvites without waiting for the leave event
+            // to round-trip through the background sync loop.
+            await client.forget(folderId);
+        });
     }
     catch (err) {
         throw new CliError(`decline failed: ${err.message}`);
@@ -164,12 +208,12 @@ export async function listSubfolders(storage, folderId) {
 }
 export async function createSubfolder(storage, folderId, name) {
     const tree = await resolveTree(storage, folderId);
-    const sub = await tree.createDirectory(name);
+    const sub = await withRateLimitRetry("createSubfolder", () => tree.createDirectory(name));
     return { id: sub.id, name };
 }
 export async function renameFolder(storage, folderId, name) {
     const tree = await resolveTree(storage, folderId);
-    await tree.setName(name);
+    await withRateLimitRetry("renameFolder", () => tree.setName(name));
     return { id: folderId, name };
 }
 export async function deleteFolder(storage, folderId) {
@@ -182,18 +226,20 @@ export async function deleteFolder(storage, folderId) {
     // store immediately; the server only accepts a forget once membership is
     // `leave`, which `tree.delete()` has just completed for the whole tree.
     const subdirectoryIds = tree.getDirectories().map((d) => d.id);
-    await tree.delete();
     const client = storage.getClient();
-    await client.forget(folderId);
-    for (const subId of subdirectoryIds) {
-        await client.forget(subId);
-    }
+    await withRateLimitRetry("deleteFolder", async () => {
+        await tree.delete();
+        await client.forget(folderId);
+        for (const subId of subdirectoryIds) {
+            await client.forget(subId);
+        }
+    });
     return { id: folderId, deleted: true };
 }
 export async function renameFile(storage, folderId, fileId, name) {
     const tree = await resolveTree(storage, folderId);
     const branch = await resolveFile(tree, fileId);
-    await branch.setName(name);
+    await withRateLimitRetry("renameFile", () => branch.setName(name));
     // `setName` resolves when the homeserver accepts the state event, but a
     // fresh CLI/UI process can still read the previous local room state for a
     // short time. Do not report success until this client has observed the new
@@ -207,12 +253,12 @@ export async function renameFile(storage, folderId, fileId, name) {
 export async function deleteFile(storage, folderId, fileId) {
     const tree = await resolveTree(storage, folderId);
     const branch = await resolveFile(tree, fileId);
-    await branch.delete();
+    await withRateLimitRetry("deleteFile", () => branch.delete());
     return { id: fileId, deleted: true };
 }
 export async function uploadFile(storage, folderId, name, bytes, mimetype) {
     const tree = await resolveTree(storage, folderId);
-    const fileId = await storage.uploadFile(tree, name, toArrayBuffer(bytes), mimetype);
+    const fileId = await withRateLimitRetry("uploadFile", () => storage.uploadFile(tree, name, toArrayBuffer(bytes), mimetype));
     return { id: fileId, name, mimetype };
 }
 export async function downloadFile(storage, folderId, fileId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telecrypt-io/storage",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "license": "BUSL-1.1",
   "type": "module",
   "main": "dist/index.js",