dropspace 0.1.0 → 0.1.1

package/dist/client/client.js

@@ -3,6 +3,28 @@ import { loadOrCreateDeviceIdentity, formatCanonicalChallenge, } from "./identit
 import { TypedEventEmitter } from "./events.js";
 import { SmartPeerSelector, } from "./peer-selection.js";
 import { ManagedPeerSession, } from "./peer-connection.js";
+export class DropspaceError extends Error {
+    code;
+    retryable;
+    retryAfterMs;
+    status;
+    constructor(code, message, opts) {
+        super(message);
+        this.name = "DropspaceError";
+        this.code = code;
+        this.retryable = opts?.retryable ?? false;
+        this.retryAfterMs = opts?.retryAfterMs;
+        this.status = opts?.status;
+    }
+}
+const PERMANENT_ERROR_CODES = new Set([
+    "APP_DISABLED",
+    "ORIGIN_NOT_ALLOWED",
+    "DEVICE_REVOKED",
+    "AUTH_FAILED",
+    "AUTH_REQUIRED",
+    "SPACE_EXPIRED",
+]);
 let reqCounter = 0;
 function nextRequestId() {
     reqCounter = (reqCounter + 1) % 1_000_000_000;
@@ -44,7 +66,9 @@ export class DropspaceClient {
     hubBySpace = new Map();
     trustedPeers = new Map();
     peerSessions = new Map();
+    peersWentOffline = new Set();
     peerQuality = new Map();
+    routeByPeer = new Map();
     pendingRequests = new Map();
     hubSeenRelayIds = new Map();
     debugLogs = [];
@@ -91,12 +115,37 @@ export class DropspaceClient {
     getDebugLogs() {
         return this.debugLogs;
     }
+    redactDebugValue(val) {
+        if (typeof val === "string") {
+            return val
+                .replace(/dinv_[A-Za-z0-9_-]+/g, "[REDACTED_INVITE_TOKEN]")
+                .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]");
+        }
+        if (Array.isArray(val)) {
+            return val.map((item) => this.redactDebugValue(item));
+        }
+        if (val && typeof val === "object") {
+            const out = {};
+            for (const [k, v] of Object.entries(val)) {
+                if (/token|secret|password|credential|privateKey|sdp/i.test(k)) {
+                    out[k] = "[REDACTED]";
+                }
+                else {
+                    out[k] = this.redactDebugValue(v);
+                }
+            }
+            return out;
+        }
+        return val;
+    }
     recordDebug(category, summary, details) {
         const entry = {
             timestamp: Date.now(),
             category,
-            summary,
-            details,
+            summary: String(this.redactDebugValue(summary)),
+            details: details
+                ? this.redactDebugValue(details)
+                : undefined,
         };
         this.debugLogs.push(entry);
         if (this.debugLogs.length > 250) {
@@ -137,12 +186,60 @@ export class DropspaceClient {
         }
         return f.bind(globalThis);
     }
+    getCoreHttpUrl() {
+        const raw = this.options.coreHttpUrl ?? this.options.baseUrl ?? "";
+        if (!raw) {
+            throw new DropspaceError("INVALID_ENVELOPE", "DropspaceClient requires coreHttpUrl or baseUrl");
+        }
+        return raw.replace(/\/+$/, "");
+    }
+    async getCapabilities(signal) {
+        const fetchFn = this.getFetch();
+        const baseUrl = this.getCoreHttpUrl();
+        const url = this.options.appId
+            ? `${baseUrl}/api/v1/apps/${encodeURIComponent(this.options.appId)}/capabilities`
+            : `${baseUrl}/api/v1/capabilities`;
+        const res = await fetchFn(url, { method: "GET", signal });
+        if (!res.ok) {
+            const errBody = (await res.json().catch(() => ({})));
+            throw new DropspaceError(errBody.code ?? "INTERNAL_ERROR", errBody.message ?? `Capabilities request failed (${res.status})`, { status: res.status, retryAfterMs: errBody.retryAfterMs });
+        }
+        return (await res.json());
+    }
+    async parseHttpError(res, fallbackPrefix) {
+        const errBody = (await res.json().catch(() => ({})));
+        const retryHeader = res.headers.get("retry-after");
+        const retryAfterMs = errBody.retryAfterMs ??
+            (retryHeader && /^\d+$/.test(retryHeader) ? Number(retryHeader) * 1000 : undefined);
+        const code = errBody.code ?? "INTERNAL_ERROR";
+        const retryable = code === "RATE_LIMITED" ||
+            code === "SERVICE_OVERLOADED" ||
+            res.status === 429 ||
+            res.status === 503;
+        return new DropspaceError(code, errBody.message ?? `${fallbackPrefix} (${res.status})`, { retryable, retryAfterMs, status: res.status });
+    }
+    isPermanentStopError(err) {
+        if (err instanceof DropspaceError) {
+            if (PERMANENT_ERROR_CODES.has(err.code))
+                return true;
+            if (err.code === "TICKET_EXPIRED" && !this.options.getAccessTicket)
+                return true;
+        }
+        return false;
+    }
     async authenticateHttpSession(signal) {
         const id = this.getIdentity();
         const fetchFn = this.getFetch();
-        const baseUrl = this.options.coreHttpUrl.replace(/\/+$/, "");
+        const baseUrl = this.getCoreHttpUrl();
+        const appId = this.options.appId;
+        const accessTicket = this.options.getAccessTicket
+            ? await this.options.getAccessTicket()
+            : undefined;
+        const chalUrl = appId
+            ? `${baseUrl}/api/v1/apps/${encodeURIComponent(appId)}/auth/challenge`
+            : `${baseUrl}/api/v1/auth/challenge`;
         // 1. Request short-lived challenge
-        const chalRes = await fetchFn(`${baseUrl}/api/v1/auth/challenge`, {
+        const chalRes = await fetchFn(chalUrl, {
             method: "POST",
             headers: { "content-type": "application/json" },
             body: JSON.stringify({
@@ -151,57 +248,72 @@ export class DropspaceClient {
                 algorithm: id.algorithm,
                 deviceLabel: id.deviceLabel,
                 purpose: "session_auth",
+                ...(appId ? { appId } : {}),
+                ...(accessTicket ? { accessTicket } : {}),
             }),
             signal,
         });
         if (!chalRes.ok) {
-            const errBody = (await chalRes.json().catch(() => ({})));
-            throw new Error(`Challenge request failed (${chalRes.status}): ${errBody.code ?? ""} ${errBody.message ?? ""}`);
+            throw await this.parseHttpError(chalRes, "Challenge request failed");
         }
         const chalData = (await chalRes.json());
         // 2. Sign canonical challenge with private key
         const canonical = formatCanonicalChallenge(chalData);
         const signature = await id.sign(canonical);
         // 3. Submit signature to obtain sessionToken
-        const verifyRes = await fetchFn(`${baseUrl}/api/v1/auth/verify`, {
+        const verifyUrl = appId
+            ? `${baseUrl}/api/v1/apps/${encodeURIComponent(appId)}/auth/verify`
+            : `${baseUrl}/api/v1/auth/verify`;
+        const verifyRes = await fetchFn(verifyUrl, {
             method: "POST",
             headers: { "content-type": "application/json" },
             body: JSON.stringify({
                 challengeId: chalData.challengeId,
                 deviceId: id.deviceId,
                 signature,
+                ...(appId ? { appId } : {}),
             }),
             signal,
         });
         if (!verifyRes.ok) {
-            const errBody = (await verifyRes.json().catch(() => ({})));
-            throw new Error(`Challenge verification failed (${verifyRes.status}): ${errBody.code ?? ""} ${errBody.message ?? ""}`);
+            throw await this.parseHttpError(verifyRes, "Challenge verification failed");
         }
         const verifyData = (await verifyRes.json());
         this.sessionToken = verifyData.sessionToken;
         this.sessionId = verifyData.sessionId;
         this.sessionExpiresAt = verifyData.expiresAt;
         this.defaultSpaceId = verifyData.defaultSpaceId;
-        this.turnCredentials = verifyData.turnCredentials;
+        this.turnCredentials = verifyData.turnCredentials ?? null;
         this.subscribedSpaces.add(verifyData.defaultSpaceId);
         this.recordDebug("security", "Authenticated HTTP challenge-response session", {
+            appId: verifyData.appId ?? appId,
             deviceId: id.deviceId,
             sessionId: verifyData.sessionId,
             securityLevel: id.securityLevel,
         });
     }
     getWsUrl() {
+        let wsUrl;
         if (this.options.coreWsUrl) {
-            return this.options.coreWsUrl;
+            wsUrl = this.options.coreWsUrl;
         }
-        const base = this.options.coreHttpUrl.replace(/\/+$/, "");
-        if (base.startsWith("https://")) {
-            return `wss://${base.slice("https://".length)}/ws`;
+        else {
+            const base = this.getCoreHttpUrl();
+            if (base.startsWith("https://")) {
+                wsUrl = `wss://${base.slice("https://".length)}/ws`;
+            }
+            else if (base.startsWith("http://")) {
+                wsUrl = `ws://${base.slice("http://".length)}/ws`;
+            }
+            else {
+                wsUrl = `${base}/ws`;
+            }
         }
-        if (base.startsWith("http://")) {
-            return `ws://${base.slice("http://".length)}/ws`;
+        if (this.options.appId && !wsUrl.includes("appId=")) {
+            const sep = wsUrl.includes("?") ? "&" : "?";
+            wsUrl = `${wsUrl}${sep}appId=${encodeURIComponent(this.options.appId)}`;
         }
-        return `${base}/ws`;
+        return wsUrl;
     }
     transitionSignalingState(next, reason) {
         if (this.signalingState === next)
@@ -304,7 +416,17 @@ export class DropspaceClient {
                 }
                 if (env.type === "error" && !settled && this.signalingState === "authenticating") {
                     settled = true;
-                    reject(new Error(`WebSocket authentication failed: ${String(env.payload.code)} - ${String(env.payload.message)}`));
+                    const errCode = String(env.payload.code ?? "AUTH_FAILED");
+                    const errMsg = String(env.payload.message ?? "WebSocket authentication failed");
+                    const retryAfterMs = typeof env.payload.retryAfterMs === "number" ? env.payload.retryAfterMs : undefined;
+                    const err = new DropspaceError(errCode, errMsg, {
+                        retryable: Boolean(env.payload.retryable),
+                        retryAfterMs,
+                    });
+                    if (this.isPermanentStopError(err)) {
+                        this.manuallyClosed = true;
+                    }
+                    reject(err);
                     return;
                 }
                 this.handleIncomingSignalingEnvelope(env);
@@ -343,25 +465,46 @@ export class DropspaceClient {
             }
         });
     }
-    scheduleSignalingReconnect() {
+    scheduleSignalingReconnect(serverRetryAfterMs) {
         if (this.manuallyClosed || this.wsReconnectTimer)
             return;
+        const maxAttempts = this.options.maxReconnectAttempts ?? 20;
+        if (this.wsReconnectAttempt >= maxAttempts) {
+            this.transitionSignalingState("closed", "max_reconnect_attempts_reached");
+            return;
+        }
         this.wsReconnectAttempt += 1;
-        const base = this.options.baseBackoffMs ?? 200;
-        const exp = Math.min(5000, base * Math.pow(2, this.wsReconnectAttempt - 1));
-        const jitter = Math.floor(Math.random() * 100);
-        const delay = exp + jitter;
+        const base = this.options.baseBackoffMs ?? 100;
+        const cap = 30_000;
+        const expCeiling = Math.min(cap, base * Math.pow(2, this.wsReconnectAttempt - 1));
+        // Full jitter prevents reconnect storms after outages
+        const fullJitterDelay = Math.floor(Math.random() * expCeiling);
+        const delay = typeof serverRetryAfterMs === "number" && serverRetryAfterMs > fullJitterDelay
+            ? serverRetryAfterMs
+            : fullJitterDelay;
         this.wsReconnectTimer = setTimeout(async () => {
             this.wsReconnectTimer = null;
             if (this.manuallyClosed)
                 return;
             try {
-                // Refresh HTTP session if expired or rejected
                 await this.authenticateHttpSession();
                 await this.connectSignalingWebSocket();
             }
-            catch {
-                this.scheduleSignalingReconnect();
+            catch (err) {
+                if (this.isPermanentStopError(err)) {
+                    this.manuallyClosed = true;
+                    this.transitionSignalingState("closed", "permanent_auth_or_policy_error");
+                    if (err instanceof DropspaceError) {
+                        this.events.emit("error", {
+                            code: err.code,
+                            message: err.message,
+                            retryable: false,
+                        });
+                    }
+                    return;
+                }
+                const retryMs = err instanceof DropspaceError ? err.retryAfterMs : undefined;
+                this.scheduleSignalingReconnect(retryMs);
             }
         }, delay);
     }
@@ -420,13 +563,20 @@ export class DropspaceClient {
             clearTimeout(pend.timer);
             this.pendingRequests.delete(env.requestId);
             if (env.type === "error") {
-                const err = new Error(`${String(env.payload.code)}: ${String(env.payload.message)}`);
-                err.code = String(env.payload.code);
+                const code = String(env.payload.code ?? "UNKNOWN_ERROR");
+                const message = String(env.payload.message ?? "Signaling error");
+                const retryable = Boolean(env.payload.retryable);
+                const retryAfterMs = typeof env.payload.retryAfterMs === "number" ? env.payload.retryAfterMs : undefined;
+                const err = new DropspaceError(code, `${code}: ${message}`, {
+                    retryable,
+                    retryAfterMs,
+                });
                 pend.reject(err);
                 this.events.emit("error", {
-                    code: String(env.payload.code),
-                    message: String(env.payload.message),
-                    retryable: Boolean(env.payload.retryable),
+                    code,
+                    message,
+                    retryable,
+                    retryAfterMs,
                 });
                 return;
             }
@@ -438,6 +588,7 @@ export class DropspaceClient {
                     code: String(env.payload.code),
                     message: String(env.payload.message),
                     retryable: Boolean(env.payload.retryable),
+                    retryAfterMs: typeof env.payload.retryAfterMs === "number" ? env.payload.retryAfterMs : undefined,
                 });
                 break;
             }
@@ -512,17 +663,35 @@ export class DropspaceClient {
                     });
                 }
                 const existingSession = this.peerSessions.get(peer.deviceId);
-                if (!peer.online && existingSession && existingSession.getState() !== "connected") {
-                    existingSession.setWaitingForPeer("peer_went_offline");
+                if (!peer.online) {
+                    this.peersWentOffline.add(peer.deviceId);
+                    if (existingSession &&
+                        existingSession.getState() !== "connected" &&
+                        !existingSession.isManuallyClosed()) {
+                        existingSession.setWaitingForPeer("peer_went_offline");
+                    }
                 }
-                else if (peer.online &&
-                    peer.deviceId !== this.identity?.deviceId &&
-                    (existingSession?.getState() === "waiting_for_peer" ||
-                        existingSession?.getState() === "reconnecting" ||
-                        ((this.options.autoConnectTrustedPeers ?? true) &&
-                            this.trustedPeers.has(peer.deviceId) &&
-                            (this.identity?.deviceId ?? "") < peer.deviceId))) {
-                    void this.connect(peer.deviceId, { spaceId }).catch(() => { });
+                else {
+                    const returnedFromOffline = this.peersWentOffline.delete(peer.deviceId);
+                    if (returnedFromOffline &&
+                        existingSession &&
+                        existingSession.getState() === "connected" &&
+                        !existingSession.isManuallyClosed() &&
+                        (this.options.autoConnectTrustedPeers ?? true) &&
+                        this.trustedPeers.has(peer.deviceId) &&
+                        (this.identity?.deviceId ?? "") < peer.deviceId) {
+                        void existingSession.forceReconnect("peer_returned_online").catch(() => { });
+                    }
+                    else if (peer.deviceId !== this.identity?.deviceId &&
+                        !existingSession?.isManuallyClosed() &&
+                        (existingSession?.getState() === "waiting_for_peer" ||
+                            existingSession?.getState() === "reconnecting" ||
+                            existingSession?.getState() === "failed" ||
+                            ((this.options.autoConnectTrustedPeers ?? true) &&
+                                this.trustedPeers.has(peer.deviceId) &&
+                                (this.identity?.deviceId ?? "") < peer.deviceId))) {
+                        void this.connect(peer.deviceId, { spaceId }).catch(() => { });
+                    }
                 }
                 break;
             }
@@ -602,12 +771,19 @@ export class DropspaceClient {
                 this.trustedPeers.delete(rev.revokedDeviceId);
                 // Immediately terminate active P2P session if the revoked device is the remote peer OR us!
                 if (rev.revokedDeviceId === this.identity?.deviceId) {
+                    this.peersBySpace.delete(rev.spaceId);
+                    for (const [key, trusted] of this.trustedPeers.entries()) {
+                        if (trusted.spaceId === rev.spaceId) {
+                            this.trustedPeers.delete(key);
+                        }
+                    }
                     for (const [peerId, sess] of this.peerSessions.entries()) {
                         sess.close(false);
                         this.peerSessions.delete(peerId);
                     }
                 }
                 else {
+                    this.peersBySpace.get(rev.spaceId)?.delete(rev.revokedDeviceId);
                     const targetSess = this.peerSessions.get(rev.revokedDeviceId);
                     if (targetSess) {
                         targetSess.close(false);
@@ -810,7 +986,7 @@ export class DropspaceClient {
         if (!this.sessionToken)
             return Array.from(this.trustedPeers.values());
         const fetchFn = this.getFetch();
-        const baseUrl = this.options.coreHttpUrl.replace(/\/+$/, "");
+        const baseUrl = this.getCoreHttpUrl();
         const res = await fetchFn(`${baseUrl}/api/v1/devices/trusted`, {
             method: "GET",
             headers: {
@@ -860,6 +1036,11 @@ export class DropspaceClient {
                 credential: this.turnCredentials.credential,
             });
         }
+        if (this.options.byoIceServers && this.options.byoIceServers.length > 0) {
+            for (const s of this.options.byoIceServers) {
+                servers.push(s);
+            }
+        }
         return servers;
     }
     getOrCreateManagedPeerSession(remoteDeviceId, spaceId) {
@@ -922,18 +1103,35 @@ export class DropspaceClient {
                 qual.rttMs = ev.rttMs;
             }
             this.peerQuality.set(remoteDeviceId, qual);
+            this.routeByPeer.set(remoteDeviceId, {
+                candidateType: ev.candidateType,
+                protocol: ev.protocol,
+                rttMs: ev.rttMs,
+            });
             this.recordDebug("webrtc", `Selected ${ev.candidateType} route for ${remoteDeviceId}`, {
                 candidateType: ev.candidateType,
                 rttMs: ev.rttMs,
             });
         });
         session.multiplexer.events.on("message", (msg) => {
+            if (!this.hasPeerPermission(remoteDeviceId, "messaging", spaceId)) {
+                this.recordDebug("security", `Dropped incoming message from unauthorized peer ${remoteDeviceId}`);
+                return;
+            }
             this.events.emit("message", msg);
         });
         session.multiplexer.events.on("transferFrame", (frame) => {
+            if (!this.hasPeerPermission(remoteDeviceId, "files", spaceId)) {
+                this.recordDebug("security", `Dropped incoming transferFrame from unauthorized peer ${remoteDeviceId}`);
+                return;
+            }
             this.events.emit("transferFrame", { peerDeviceId: remoteDeviceId, frame });
         });
         session.multiplexer.events.on("crdtFrame", (frame) => {
+            if (!this.hasPeerPermission(remoteDeviceId, "crdt", spaceId)) {
+                this.recordDebug("security", `Dropped incoming crdtFrame from unauthorized peer ${remoteDeviceId}`);
+                return;
+            }
             this.events.emit("crdtFrame", { peerDeviceId: remoteDeviceId, frame });
         });
         session.multiplexer.events.on("hubRelayFrame", (frame) => {
@@ -1062,6 +1260,15 @@ export class DropspaceClient {
     getPeerSession(peerDeviceId) {
         return this.peerSessions.get(peerDeviceId);
     }
+    getConnectedPeerIds() {
+        const ids = [];
+        for (const [peerId, sess] of this.peerSessions.entries()) {
+            if (sess.getState() === "connected") {
+                ids.push(peerId);
+            }
+        }
+        return ids;
+    }
     async sendBinaryMessage(peerDeviceId, payload, options = {}) {
         if (options.viaHubDeviceId) {
             const hubSess = this.peerSessions.get(options.viaHubDeviceId);
@@ -1148,8 +1355,10 @@ export class DropspaceClient {
         this.pendingRequests.clear();
         for (const sess of this.peerSessions.values()) {
             sess.close(false);
+            sess.multiplexer.dispose();
         }
         this.peerSessions.clear();
+        this.routeByPeer.clear();
         if (this.ws) {
             try {
                 this.ws.close(1000, "client_closed");
@@ -1160,6 +1369,42 @@ export class DropspaceClient {
         this.transitionSignalingState("closed", "manual_close");
         this.events.removeAllListeners();
     }
+    hasPeerPermission(peerDeviceId, permission, spaceId) {
+        if (spaceId) {
+            if (this.revokedPeersBySpace.get(spaceId)?.has(peerDeviceId)) {
+                return false;
+            }
+            const presence = this.peersBySpace.get(spaceId)?.get(peerDeviceId);
+            if (presence) {
+                return presence.permissions.includes(permission);
+            }
+            for (const trusted of this.trustedPeers.values()) {
+                if (trusted.peerDeviceId === peerDeviceId && trusted.spaceId === spaceId) {
+                    return trusted.permissions.includes(permission);
+                }
+            }
+            return false;
+        }
+        for (const [spId, spacePeers] of this.peersBySpace.entries()) {
+            if (this.revokedPeersBySpace.get(spId)?.has(peerDeviceId))
+                continue;
+            const presence = spacePeers.get(peerDeviceId);
+            if (presence && presence.permissions.includes(permission)) {
+                return true;
+            }
+        }
+        for (const trusted of this.trustedPeers.values()) {
+            if (trusted.peerDeviceId === peerDeviceId &&
+                !this.revokedPeersBySpace.get(trusted.spaceId)?.has(peerDeviceId) &&
+                trusted.permissions.includes(permission)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getPeerRouteInfo(peerDeviceId) {
+        return this.routeByPeer.get(peerDeviceId) ?? null;
+    }
     getActiveResourceCounts() {
         return {
             listenerCount: this.events.listenerCount(),