@openmarket/rooms-client 0.4.2 → 0.5.0

package/dist/agent/sidebar-model.d.ts

@@ -74,6 +74,9 @@ export declare class SidebarModel {
     constructor(deps: SidebarModelDeps);
     snapshot(): SidebarSnapshot;
     onUpdate(listener: () => void): () => void;
+    /** Apply a same-user realtime DM counter without refetching the full room
+     *  directory. Username is the stable DM key used by the sidebar model. */
+    applyDmUnread(username: string, unread: number): void;
     /**
      * Post-mutation refresh: if a poll-triggered load is already in flight it
      * may predate the caller's writes, so wait it out and load AGAIN. Readers

package/dist/agent/sidebar-model.js

@@ -112,6 +112,34 @@ export class SidebarModel {
             this.listeners.delete(listener);
         };
     }
+    /** Apply a same-user realtime DM counter without refetching the full room
+     *  directory. Username is the stable DM key used by the sidebar model. */
+    applyDmUnread(username, unread) {
+        const key = normalizeDmUsername(username);
+        if (!key)
+            return;
+        const normalizedUnread = Number.isFinite(unread) ? Math.max(0, Math.floor(unread)) : 0;
+        let found = false;
+        let changed = false;
+        const next = this.snapshotValue.dms.map((dm) => {
+            if (normalizeDmUsername(dm.username) !== key)
+                return dm;
+            found = true;
+            if (dm.unread === normalizedUnread)
+                return dm;
+            changed = true;
+            return { ...dm, unread: normalizedUnread };
+        });
+        if (!found && normalizedUnread > 0) {
+            next.push({ username: username.replace(/^@+/, ""), unread: normalizedUnread });
+            changed = true;
+        }
+        if (!changed)
+            return;
+        this.snapshotValue = { ...this.snapshotValue, dms: next };
+        for (const listener of this.listeners)
+            listener();
+    }
     /**
      * Post-mutation refresh: if a poll-triggered load is already in flight it
      * may predate the caller's writes, so wait it out and load AGAIN. Readers
@@ -160,3 +188,6 @@ export class SidebarModel {
         });
     }
 }
+function normalizeDmUsername(username) {
+    return username.trim().replace(/^@+/, "").toLowerCase();
+}

package/dist/client.d.ts

@@ -242,6 +242,9 @@ export { workspaceRoomName } from "./names.js";
 export declare function listRooms(config: RoomClientConfig, request?: RoomListRequest): Promise<RoomListResult>;
 export declare function createRoom(config: RoomClientConfig, request: RoomCreateRequest): Promise<RoomCreateResult>;
 export declare function inviteRoom(config: RoomClientConfig, request: RoomInviteRequest): Promise<RoomInviteResult>;
+/** Invite over an already-authenticated socket. Long-lived GUI/TUI sessions
+ * use this path so a one-shot invite cannot create a second connection. */
+export declare function inviteRoomOnClient(client: RoomWsClient, request: RoomInviteRequest, timeoutMs?: number): Promise<RoomInvitedPayload>;
 export declare function removeRoomMember(config: RoomClientConfig, request: RoomRemoveMemberRequest): Promise<RoomRemoveMemberResult>;
 export declare function reportRoomTarget(config: RoomClientConfig, request: RoomReportRequest): Promise<RoomReportResult>;
 export declare function muteRoomMember(config: RoomClientConfig, request: RoomMuteRequest): Promise<RoomMuteResult>;

package/dist/client.js

@@ -101,9 +101,7 @@ async function createRoomViaWebSocket(config, request) {
 export async function inviteRoom(config, request) {
     // `@user` and `user` are the same person: strip the typing syntax once,
     // before either transport (the relay resolves the bare name).
-    const normalized = request.username
-        ? { ...request, username: request.username.trim().replace(/^@+/, "") }
-        : request;
+    const normalized = normalizeRoomInviteRequest(request);
     if (!config.webSocketCtor) {
         try {
             return await inviteRoomViaHttp(config, normalized);
@@ -119,24 +117,35 @@ async function inviteRoomViaWebSocket(config, request) {
     const client = new RoomWsClient(config);
     try {
         const auth = await client.connect();
-        const requestId = randomUUID();
-        client.send({
-            type: RoomClientMessageType.INVITE,
-            payload: {
-                requestId,
-                room: request.room,
-                ...(request.username ? { username: request.username } : {}),
-                ...(request.userId ? { userId: request.userId } : {}),
-            },
-            timestamp: Date.now(),
-        });
-        const invited = await client.waitFor(RoomServerMessageType.ROOM_INVITED, (msg) => msg.payload.requestId === requestId, undefined, requestId);
-        return { auth, invite: invited.payload };
+        return { auth, invite: await inviteRoomOnClient(client, request) };
     }
     finally {
         client.close();
     }
 }
+/** Invite over an already-authenticated socket. Long-lived GUI/TUI sessions
+ * use this path so a one-shot invite cannot create a second connection. */
+export async function inviteRoomOnClient(client, request, timeoutMs) {
+    const normalized = normalizeRoomInviteRequest(request);
+    const requestId = randomUUID();
+    client.send({
+        type: RoomClientMessageType.INVITE,
+        payload: {
+            requestId,
+            room: normalized.room,
+            ...(normalized.username ? { username: normalized.username } : {}),
+            ...(normalized.userId ? { userId: normalized.userId } : {}),
+        },
+        timestamp: Date.now(),
+    });
+    const invited = await client.waitFor(RoomServerMessageType.ROOM_INVITED, (msg) => msg.payload.requestId === requestId, timeoutMs, requestId);
+    return invited.payload;
+}
+function normalizeRoomInviteRequest(request) {
+    return request.username
+        ? { ...request, username: request.username.trim().replace(/^@+/, "") }
+        : request;
+}
 export async function removeRoomMember(config, request) {
     if (!config.webSocketCtor) {
         try {

package/dist/social-client.d.ts

@@ -330,6 +330,12 @@ export declare function listRoomChannelMembers(config: RoomSocialConfig, roomId:
 export declare function removeSpaceMember(config: RoomSocialConfig, spaceId: string, targetUserId: string): Promise<{
     removed?: boolean;
 }>;
+/** Leave a server as the authenticated caller. This is deliberately separate
+ * from the manager-only member-removal route so clients never send their own
+ * userId as authorization data. */
+export declare function leaveSpace(config: RoomSocialConfig, spaceId: string): Promise<{
+    left?: boolean;
+}>;
 export declare function changeSpaceMemberRole(config: RoomSocialConfig, spaceId: string, targetUserId: string, role: "admin" | "librarian" | "member"): Promise<RoomSpaceMember>;
 /** Set (string) or clear (null) a member's per-space nickname; the store validates and enforces uniqueness. */
 export declare function setSpaceMemberNickname(config: RoomSocialConfig, spaceId: string, targetUserId: string, nickname: string | null): Promise<RoomSpaceMember>;

package/dist/social-client.js

@@ -500,6 +500,14 @@ export async function listRoomChannelMembers(config, roomId, options = {}) {
 export async function removeSpaceMember(config, spaceId, targetUserId) {
     return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}`, { method: "DELETE" });
 }
+/** Leave a server as the authenticated caller. This is deliberately separate
+ * from the manager-only member-removal route so clients never send their own
+ * userId as authorization data. */
+export async function leaveSpace(config, spaceId) {
+    return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/membership`, {
+        method: "DELETE",
+    });
+}
 export async function changeSpaceMemberRole(config, spaceId, targetUserId, role) {
     const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/role`, { method: "PATCH", body: { role } });
     return result.member;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmarket/rooms-client",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "OM Rooms protocol client: wire types, WebSocket + REST clients, and chat view-models. Browser-safe (no node:/bun: imports).",
   "type": "module",
   "license": "Apache-2.0",

package/src/agent/sidebar-model.ts

@@ -186,6 +186,30 @@ export class SidebarModel {
     };
   }
 
+  /** Apply a same-user realtime DM counter without refetching the full room
+   *  directory. Username is the stable DM key used by the sidebar model. */
+  applyDmUnread(username: string, unread: number): void {
+    const key = normalizeDmUsername(username);
+    if (!key) return;
+    const normalizedUnread = Number.isFinite(unread) ? Math.max(0, Math.floor(unread)) : 0;
+    let found = false;
+    let changed = false;
+    const next = this.snapshotValue.dms.map((dm) => {
+      if (normalizeDmUsername(dm.username) !== key) return dm;
+      found = true;
+      if (dm.unread === normalizedUnread) return dm;
+      changed = true;
+      return { ...dm, unread: normalizedUnread };
+    });
+    if (!found && normalizedUnread > 0) {
+      next.push({ username: username.replace(/^@+/, ""), unread: normalizedUnread });
+      changed = true;
+    }
+    if (!changed) return;
+    this.snapshotValue = { ...this.snapshotValue, dms: next };
+    for (const listener of this.listeners) listener();
+  }
+
   /**
    * Post-mutation refresh: if a poll-triggered load is already in flight it
    * may predate the caller's writes, so wait it out and load AGAIN. Readers
@@ -233,3 +257,7 @@ export class SidebarModel {
     });
   }
 }
+
+function normalizeDmUsername(username: string): string {
+  return username.trim().replace(/^@+/, "").toLowerCase();
+}

package/src/client.ts

@@ -443,9 +443,7 @@ export async function inviteRoom(
 ): Promise<RoomInviteResult> {
   // `@user` and `user` are the same person: strip the typing syntax once,
   // before either transport (the relay resolves the bare name).
-  const normalized: RoomInviteRequest = request.username
-    ? { ...request, username: request.username.trim().replace(/^@+/, "") }
-    : request;
+  const normalized = normalizeRoomInviteRequest(request);
   if (!config.webSocketCtor) {
     try {
       return await inviteRoomViaHttp(config, normalized);
@@ -463,29 +461,46 @@ async function inviteRoomViaWebSocket(
   const client = new RoomWsClient(config);
   try {
     const auth = await client.connect();
-    const requestId = randomUUID();
-    client.send({
-      type: RoomClientMessageType.INVITE,
-      payload: {
-        requestId,
-        room: request.room,
-        ...(request.username ? { username: request.username } : {}),
-        ...(request.userId ? { userId: request.userId } : {}),
-      },
-      timestamp: Date.now(),
-    });
-    const invited = await client.waitFor(
-      RoomServerMessageType.ROOM_INVITED,
-      (msg) => msg.payload.requestId === requestId,
-      undefined,
-      requestId,
-    );
-    return { auth, invite: invited.payload };
+    return { auth, invite: await inviteRoomOnClient(client, request) };
   } finally {
     client.close();
   }
 }
 
+/** Invite over an already-authenticated socket. Long-lived GUI/TUI sessions
+ * use this path so a one-shot invite cannot create a second connection. */
+export async function inviteRoomOnClient(
+  client: RoomWsClient,
+  request: RoomInviteRequest,
+  timeoutMs?: number,
+): Promise<RoomInvitedPayload> {
+  const normalized = normalizeRoomInviteRequest(request);
+  const requestId = randomUUID();
+  client.send({
+    type: RoomClientMessageType.INVITE,
+    payload: {
+      requestId,
+      room: normalized.room,
+      ...(normalized.username ? { username: normalized.username } : {}),
+      ...(normalized.userId ? { userId: normalized.userId } : {}),
+    },
+    timestamp: Date.now(),
+  });
+  const invited = await client.waitFor(
+    RoomServerMessageType.ROOM_INVITED,
+    (msg) => msg.payload.requestId === requestId,
+    timeoutMs,
+    requestId,
+  );
+  return invited.payload;
+}
+
+function normalizeRoomInviteRequest(request: RoomInviteRequest): RoomInviteRequest {
+  return request.username
+    ? { ...request, username: request.username.trim().replace(/^@+/, "") }
+    : request;
+}
+
 export async function removeRoomMember(
   config: RoomClientConfig,
   request: RoomRemoveMemberRequest,

package/src/social-client.ts

@@ -1044,6 +1044,18 @@ export async function removeSpaceMember(
   );
 }
 
+/** Leave a server as the authenticated caller. This is deliberately separate
+ * from the manager-only member-removal route so clients never send their own
+ * userId as authorization data. */
+export async function leaveSpace(
+  config: RoomSocialConfig,
+  spaceId: string,
+): Promise<{ left?: boolean }> {
+  return socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/membership`, {
+    method: "DELETE",
+  });
+}
+
 export async function changeSpaceMemberRole(
   config: RoomSocialConfig,
   spaceId: string,