@telecrypt-io/storage 0.2.8 → 0.2.10

package/dist/TeleCryptIOStorage.d.ts

@@ -213,6 +213,21 @@ export declare class TeleCryptIOStorage {
      */
     createTree(name: string): Promise<TreeSpace>;
     listTrees(): Promise<TreeSpace[]>;
+    /**
+     * Creates a subdirectory (nested tree space) under `parent` and links it
+     * with the parent's space.child / the child's space.parent state events.
+     *
+     * Mirrors `createTree`'s workaround for the same matrix-js-sdk race:
+     * `MSC3089TreeSpace.createDirectory()` calls `unstableCreateFileTree()`,
+     * which creates the room via a plain `createRoom()` HTTP call and then
+     * immediately wraps the result by looking the room up in the *local*
+     * client store — throwing `Error("Unknown room")` when the background
+     * sync loop hasn't surfaced the new room yet. Without the workaround the
+     * subfolder room is created server-side but never linked (no space.child
+     * event), leaving an orphaned room and a spurious failure for a folder
+     * that in fact exists.
+     */
+    createSubtree(parent: TreeSpace, name: string): Promise<TreeSpace>;
     getTree(roomId: string): TreeSpace | null;
     /**
      * Lists the participants of a shared folder (tree space) and their role,

package/dist/TeleCryptIOStorage.js

@@ -1,4 +1,4 @@
-import { ClientEvent, createClient, MatrixEvent, SyncState } from "matrix-js-sdk";
+import { ClientEvent, createClient, EventType, MatrixEvent, SyncState } from "matrix-js-sdk";
 import { Method } from "matrix-js-sdk/lib/http-api/method.js";
 import { ClientPrefix } from "matrix-js-sdk/lib/http-api/prefix.js";
 import { encryptAttachment, decryptAttachment } from "matrix-encrypt-attachment";
@@ -306,6 +306,59 @@ export class TeleCryptIOStorage {
         }
         return trees;
     }
+    /**
+     * Creates a subdirectory (nested tree space) under `parent` and links it
+     * with the parent's space.child / the child's space.parent state events.
+     *
+     * Mirrors `createTree`'s workaround for the same matrix-js-sdk race:
+     * `MSC3089TreeSpace.createDirectory()` calls `unstableCreateFileTree()`,
+     * which creates the room via a plain `createRoom()` HTTP call and then
+     * immediately wraps the result by looking the room up in the *local*
+     * client store — throwing `Error("Unknown room")` when the background
+     * sync loop hasn't surfaced the new room yet. Without the workaround the
+     * subfolder room is created server-side but never linked (no space.child
+     * event), leaving an orphaned room and a spurious failure for a folder
+     * that in fact exists.
+     */
+    async createSubtree(parent, name) {
+        const knownRoomIdsBefore = new Set(this.client.getRooms().map((r) => r.roomId));
+        try {
+            // The `await` here is load-bearing: without it, the promise's
+            // eventual rejection would happen after this try/catch has already
+            // returned, bypassing the recovery logic below entirely.
+            return (await parent.createDirectory(name));
+        }
+        catch (err) {
+            if (!(err instanceof Error) || err.message !== "Unknown room")
+                throw err;
+            const newRoomId = await new Promise((resolve, reject) => {
+                const deadline = Date.now() + 15000;
+                const poll = () => {
+                    const found = this.client.getRooms().find((r) => !knownRoomIdsBefore.has(r.roomId));
+                    if (found) {
+                        resolve(found.roomId);
+                        return;
+                    }
+                    if (Date.now() >= deadline) {
+                        reject(new Error("createSubtree: room was created server-side but never appeared in this client's local sync state"));
+                        return;
+                    }
+                    setTimeout(poll, 200);
+                };
+                poll();
+            });
+            const tree = this.client.unstableGetFileTreeSpace(newRoomId);
+            if (!tree) {
+                throw new Error(`createSubtree: room ${newRoomId} appeared but is not a valid file tree space`);
+            }
+            // The room appeared in sync, but `createDirectory` threw before it
+            // could send the space.child / space.parent link events. Send them
+            // now so the subfolder is actually reachable from its parent.
+            await this.client.sendStateEvent(parent.id, EventType.SpaceChild, { via: [this.client.getDomain()] }, newRoomId);
+            await this.client.sendStateEvent(newRoomId, EventType.SpaceParent, { via: [this.client.getDomain()] }, parent.id);
+            return tree;
+        }
+    }
     getTree(roomId) {
         return this.client.unstableGetFileTreeSpace(roomId);
     }

package/dist/core/oidc.d.ts

@@ -61,12 +61,18 @@ export declare function isDeviceAccessTokenError(result: DeviceAccessTokenRespon
  * internally by matrix-js-sdk/oidc-client-ts (`mx_oidc_`-prefixed keys) — the
  * caller does not need to manage them; `completeAuthorizationCodeFlow` reads
  * them back after the redirect.
+ *
+ * `deviceId` is optional: when supplied, it is embedded in the requested
+ * scope (MSC2967) so MAS grants THAT device instead of minting a fresh one —
+ * the web UI passes a stable per-browser device id so repeated logins reuse
+ * the same Matrix device instead of accumulating one device per login.
  */
 export declare function beginAuthorizationCodeFlow(opts: {
     authMetadata: OidcClientConfig;
     clientId: string;
     homeserverUrl: string;
     redirectUri: string;
+    deviceId?: string;
 }): Promise<string>;
 /** Completes the authorization-code exchange after the `?code&state` redirect. */
 export declare function completeAuthorizationCodeFlow(code: string, state: string): Promise<{

package/dist/core/oidc.js

@@ -10,6 +10,7 @@
  */
 import { createClient } from "matrix-js-sdk";
 import { registerOidcClient, generateScope, generateOidcAuthorizationUrl, completeAuthorizationCodeGrant, startDeviceAuthorization, waitForDeviceAuthorization, } from "matrix-js-sdk/lib/oidc/index.js";
+import { OidcClient, WebStorageStateStore } from "oidc-client-ts";
 import { CliError } from "./errors.js";
 /**
  * Discovers the OIDC/MAS issuer + endpoints for a homeserver, via
@@ -84,9 +85,41 @@ export function isDeviceAccessTokenError(result) {
  * internally by matrix-js-sdk/oidc-client-ts (`mx_oidc_`-prefixed keys) — the
  * caller does not need to manage them; `completeAuthorizationCodeFlow` reads
  * them back after the redirect.
+ *
+ * `deviceId` is optional: when supplied, it is embedded in the requested
+ * scope (MSC2967) so MAS grants THAT device instead of minting a fresh one —
+ * the web UI passes a stable per-browser device id so repeated logins reuse
+ * the same Matrix device instead of accumulating one device per login.
  */
 export async function beginAuthorizationCodeFlow(opts) {
     const nonce = crypto.randomUUID();
+    if (opts.deviceId) {
+        // matrix-js-sdk's generateOidcAuthorizationUrl hardcodes
+        // generateScope() with no device id, so every login would mint a fresh
+        // Matrix device. Build the URL ourselves with the stable device id in
+        // the requested scope (MSC2967) so MAS grants THAT device — mirroring
+        // matrix-js-sdk's construction exactly (same state store, same user
+        // state shape) so completeAuthorizationCodeFlow still works unchanged.
+        const scope = generateScope(opts.deviceId);
+        const oidcClient = new OidcClient({
+            ...opts.authMetadata,
+            signingKeys: opts.authMetadata.signingKeys ?? undefined,
+            metadata: opts.authMetadata,
+            client_id: opts.clientId,
+            redirect_uri: opts.redirectUri,
+            authority: opts.authMetadata.issuer,
+            response_mode: "query",
+            response_type: "code",
+            scope,
+            stateStore: new WebStorageStateStore({ prefix: "mx_oidc_", store: window.sessionStorage }),
+        });
+        const userState = { homeserverUrl: opts.homeserverUrl, nonce };
+        const request = await oidcClient.createSigninRequest({
+            state: userState,
+            nonce,
+        });
+        return request.url;
+    }
     return generateOidcAuthorizationUrl({
         metadata: opts.authMetadata,
         clientId: opts.clientId,

package/dist/core/operations.js

@@ -208,7 +208,7 @@ export async function listSubfolders(storage, folderId) {
 }
 export async function createSubfolder(storage, folderId, name) {
     const tree = await resolveTree(storage, folderId);
-    const sub = await withRateLimitRetry("createSubfolder", () => tree.createDirectory(name));
+    const sub = await withRateLimitRetry("createSubfolder", () => storage.createSubtree(tree, name));
     return { id: sub.id, name };
 }
 export async function renameFolder(storage, folderId, name) {

package/package.json

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