@massalabs/gossip-sdk 0.0.2-dev.20260319090011 → 0.0.2-dev.20260320093215

package/dist/db/queries/messages.d.ts

@@ -16,6 +16,7 @@ export declare class MessageQueries {
     batchInsert(values: MessageInsert[]): Promise<void>;
     updateById(id: number, data: Partial<MessageInsert>): Promise<void>;
     deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
+    deleteById(id: number): Promise<void>;
     deleteDeliveredKeepAlive(ownerUserId: string): Promise<void>;
     getOutgoingSentByOwner(ownerUserId: string): Promise<MessageRow[]>;
     getWaitingCount(ownerUserId: string, contactUserId: string): Promise<number>;

package/dist/db/queries/messages.js

@@ -83,6 +83,11 @@ export class MessageQueries {
             .delete(schema.messages)
             .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId)));
     }
+    async deleteById(id) {
+        await this.conn.db
+            .delete(schema.messages)
+            .where(eq(schema.messages.id, id));
+    }
     async deleteDeliveredKeepAlive(ownerUserId) {
         await this.conn.db
             .delete(schema.messages)

package/dist/gossip.d.ts

@@ -6,6 +6,7 @@ import { MessageService } from './services/message.js';
 import { AuthService } from './services/auth.js';
 import { ProfileService } from './services/profile.js';
 import { ContactService } from './services/contact.js';
+import { SelfMessageService } from './services/selfMessage.js';
 import { type ValidationResult } from './utils/validation.js';
 import { type StorageConfig } from './db/index.js';
 import { Queries } from './db/queries/index.js';
@@ -52,6 +53,7 @@ declare class GossipSdk {
     private _message;
     private _refresh;
     private _contact;
+    private _selfMessage;
     /**
      * Initialize the SDK. Call once at app startup.
      */
@@ -104,6 +106,8 @@ declare class GossipSdk {
     get announcements(): AnnouncementService;
     /** Contact management */
     get contacts(): ContactService;
+    /** Self-message service */
+    get selfMessages(): SelfMessageService;
     /**
      * Update state for all discussions:
      * - Cleanup orphaned peers

package/dist/gossip.js

@@ -47,6 +47,7 @@ import { RefreshService } from './services/refresh.js';
 import { AuthService } from './services/auth.js';
 import { ProfileService } from './services/profile.js';
 import { ContactService } from './services/contact.js';
+import { SelfMessageService } from './services/selfMessage.js';
 import { validateUserIdFormat, validateUsernameFormat, } from './utils/validation.js';
 import { QueueManager } from './utils/queue.js';
 import { encodeUserId, decodeUserId } from './utils/userId.js';
@@ -149,6 +150,12 @@ class GossipSdk {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "_selfMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
     }
     // ─────────────────────────────────────────────────────────────────
     // Lifecycle
@@ -234,6 +241,8 @@ class GossipSdk {
         this._discussion = new DiscussionService(this._announcement, session, this.eventEmitter, queries);
         this._message = new MessageService(messageProtocol, session, this.eventEmitter, config, queries);
         this._refresh = new RefreshService(this._message, this._discussion, this._announcement, session, this.eventEmitter, queries, this.config);
+        this._selfMessage = new SelfMessageService(queries, session.userIdEncoded, encryptionKey);
+        await this._selfMessage.ensureDiscussionExists();
         // Publish gossip ID (public key) on messageProtocol so the user is discoverable.
         // Non-blocking: login must succeed even when the API is unreachable.
         this._auth.publishPublicKey(session.ourPk, session.userIdEncoded, queries).catch(err => {
@@ -284,6 +293,7 @@ class GossipSdk {
         this._message = null;
         this._refresh = null;
         this._contact = null;
+        this._selfMessage = null;
         // Clear message queues
         this.messageQueues.clear();
         // Reset to initialized state
@@ -412,6 +422,14 @@ class GossipSdk {
         }
         return this._contact;
     }
+    /** Self-message service */
+    get selfMessages() {
+        this.requireSession();
+        if (!this._selfMessage) {
+            throw new Error('Self-message service not initialized');
+        }
+        return this._selfMessage;
+    }
     /**
      * Update state for all discussions:
      * - Cleanup orphaned peers

package/dist/index.d.ts

@@ -27,3 +27,4 @@ export * from './wasm/index.js';
 export * from './db/db.js';
 export * from './db/queries/index.js';
 export * from './db/sqlite.js';
+export { SELF_CONTACT_ID } from './services/selfMessage.js';

package/dist/index.js

@@ -27,3 +27,4 @@ export * from './wasm/index.js';
 export * from './db/db.js';
 export * from './db/queries/index.js';
 export * from './db/sqlite.js';
+export { SELF_CONTACT_ID } from './services/selfMessage.js';

package/dist/services/refresh.js

@@ -10,6 +10,7 @@ import { SessionStatus } from '../wasm/bindings.js';
 import { decodeUserId, encodeUserId } from '../utils/userId.js';
 import { Logger } from '../utils/logs.js';
 import { SdkEventType } from '../core/SdkEventEmitter.js';
+import { SELF_CONTACT_ID } from './selfMessage.js';
 const logger = new Logger('RefreshService');
 /**
  * Service for refreshing sessions and handling keep-alive messages.
@@ -104,6 +105,9 @@ export class RefreshService {
         const allRows = await this.queries.discussions.getByOwner(ownerUserId);
         const discussions = toSortedDiscussions(allRows);
         for (const discussion of discussions) {
+            if (discussion.contactUserId === SELF_CONTACT_ID) {
+                continue;
+            }
             const peerId = decodeUserId(discussion.contactUserId);
             const status = this.session.peerSessionStatus(peerId);
             const previous = this.sessionStatusMap.get(discussion.contactUserId);
@@ -145,7 +149,9 @@ export class RefreshService {
                 discussions: discussions.map(discussion => discussion.contactUserId),
             });
             // Step 0: cleanup orphaned sessions
-            const discussionPeerIds = new Set(discussions.map(discussion => discussion.contactUserId));
+            const discussionPeerIds = new Set(discussions
+                .filter(discussion => discussion.contactUserId !== SELF_CONTACT_ID)
+                .map(discussion => discussion.contactUserId));
             const sessionPeers = this.session.peerList();
             for (const peerId of sessionPeers) {
                 const encoded = encodeUserId(peerId);
@@ -160,6 +166,9 @@ export class RefreshService {
             const refreshResult = await this.session.refresh();
             const keepAlivePeerIds = refreshResult.map(peer => encodeUserId(peer));
             for (const discussion of discussions) {
+                if (discussion.contactUserId === SELF_CONTACT_ID) {
+                    continue;
+                }
                 const peerId = decodeUserId(discussion.contactUserId);
                 const status = this.session.peerSessionStatus(peerId);
                 await this.handleSessionStatus(discussion, status);
@@ -168,6 +177,9 @@ export class RefreshService {
             const refreshRows = await this.queries.discussions.getByOwner(ownerUserId);
             const discussionsAfterRefresh = toSortedDiscussions(refreshRows);
             const activePendingDiscussions = discussionsAfterRefresh.filter(discussion => {
+                if (discussion.contactUserId === SELF_CONTACT_ID) {
+                    return false;
+                }
                 const status = this.session.peerSessionStatus(decodeUserId(discussion.contactUserId));
                 return [
                     SessionStatus.Active,
@@ -185,6 +197,9 @@ export class RefreshService {
             [SessionStatus.Active, SessionStatus.Saturated].includes(this.session.peerSessionStatus(decodeUserId(discussion.contactUserId))));
             const keepAliveSet = new Set(keepAlivePeerIds);
             for (const discussion of activeEstablishedDiscussions) {
+                if (discussion.contactUserId === SELF_CONTACT_ID) {
+                    continue;
+                }
                 if (!discussion.weAccepted)
                     continue;
                 // Send keep alive message if needed

package/dist/services/selfMessage.d.ts

@@ -0,0 +1,28 @@
+import { Queries } from '../db/queries/index.js';
+import type { EncryptionKey } from '../wasm/encryption.js';
+import { type Message } from '../db/db.js';
+export declare const SELF_CONTACT_ID = "__self__";
+export declare class SelfMessageService {
+    private readonly queries;
+    private readonly ownerUserId;
+    private readonly encryptionKey;
+    constructor(queries: Queries, ownerUserId: string, encryptionKey: EncryptionKey);
+    ensureDiscussionExists(): Promise<void>;
+    private encryptContent;
+    private decryptContent;
+    send(content: string): Promise<Message>;
+    getMessages(): Promise<Message[]>;
+    editMessage(id: number, newContent: string): Promise<void>;
+    deleteMessage(id: number): Promise<void>;
+    sendReaction(emoji: string, originalMessageDbId: number): Promise<{
+        id: number;
+        emoji: string;
+        originalMessageId: number;
+    }>;
+    removeReaction(reactionId: number): Promise<void>;
+    getReactions(): Promise<{
+        id: number;
+        emoji: string;
+        originalMessageId: number;
+    }[]>;
+}

package/dist/services/selfMessage.js

@@ -0,0 +1,194 @@
+import { decryptAead, encryptAead, nonceFromBytes, } from '../wasm/encryption.js';
+import { MessageDirection, MessageStatus, MessageType, } from '../db/db.js';
+import { encodeToBase64, decodeFromBase64 } from '../utils/base64.js';
+export const SELF_CONTACT_ID = '__self__';
+const AAD_EMPTY = new Uint8Array(0);
+const ZERO_NONCE_BYTES = new Uint8Array(16);
+export class SelfMessageService {
+    constructor(queries, ownerUserId, encryptionKey) {
+        Object.defineProperty(this, "queries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queries
+        });
+        Object.defineProperty(this, "ownerUserId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ownerUserId
+        });
+        Object.defineProperty(this, "encryptionKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: encryptionKey
+        });
+    }
+    async ensureDiscussionExists() {
+        const existing = await this.queries.discussions.getByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        if (existing)
+            return;
+        const now = new Date();
+        await this.queries.discussions.insert({
+            ownerUserId: this.ownerUserId,
+            contactUserId: SELF_CONTACT_ID,
+            weAccepted: true,
+            sendAnnouncement: null,
+            direction: 'initiated',
+            nextSeeker: null,
+            initiationAnnouncement: null,
+            announcementMessage: null,
+            lastSyncTimestamp: null,
+            customName: null,
+            lastMessageId: null,
+            lastMessageContent: null,
+            lastMessageTimestamp: null,
+            unreadCount: 0,
+            pinned: false,
+            killedNextRetryAt: null,
+            saturatedRetryAt: null,
+            saturatedRetryDone: false,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+    async encryptContent(plaintext) {
+        const nonce = await nonceFromBytes(ZERO_NONCE_BYTES);
+        const ciphertext = await encryptAead(this.encryptionKey, nonce, new TextEncoder().encode(plaintext), AAD_EMPTY);
+        // Store only ciphertext; nonce is a fixed zero value for all messages.
+        return encodeToBase64(ciphertext);
+    }
+    async decryptContent(content) {
+        const cipherBytes = decodeFromBase64(content);
+        const nonce = await nonceFromBytes(ZERO_NONCE_BYTES);
+        const plaintextBytes = await decryptAead(this.encryptionKey, nonce, cipherBytes, AAD_EMPTY);
+        if (!plaintextBytes) {
+            throw new Error('Failed to decrypt self message');
+        }
+        return new TextDecoder().decode(plaintextBytes);
+    }
+    async send(content) {
+        const encryptedContent = await this.encryptContent(content);
+        const now = new Date();
+        const id = await this.queries.messages.insert({
+            ownerUserId: this.ownerUserId,
+            contactUserId: SELF_CONTACT_ID,
+            content: encryptedContent,
+            type: MessageType.TEXT,
+            direction: MessageDirection.OUTGOING,
+            status: MessageStatus.SENT,
+            timestamp: now,
+        });
+        const discussion = await this.queries.discussions.getByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        if (discussion?.id != null) {
+            await this.queries.discussions.updateById(discussion.id, {
+                lastMessageId: id,
+                lastMessageContent: null,
+                lastMessageTimestamp: now,
+                updatedAt: now,
+            });
+        }
+        return {
+            id,
+            ownerUserId: this.ownerUserId,
+            contactUserId: SELF_CONTACT_ID,
+            content,
+            type: MessageType.TEXT,
+            direction: MessageDirection.OUTGOING,
+            status: MessageStatus.SENT,
+            timestamp: now,
+        };
+    }
+    async getMessages() {
+        const rows = await this.queries.messages.getVisibleByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        const result = [];
+        for (const row of rows) {
+            try {
+                const plaintext = await this.decryptContent(row.content);
+                result.push({
+                    id: row.id,
+                    ownerUserId: row.ownerUserId,
+                    contactUserId: row.contactUserId,
+                    content: plaintext,
+                    type: row.type,
+                    direction: MessageDirection.OUTGOING,
+                    status: row.status,
+                    timestamp: row.timestamp,
+                });
+            }
+            catch {
+                // Skip messages that cannot be decrypted
+            }
+        }
+        return result;
+    }
+    async editMessage(id, newContent) {
+        const row = await this.queries.messages.getById(id);
+        if (!row)
+            return;
+        const encryptedContent = await this.encryptContent(newContent);
+        const existingMetadata = row.metadata
+            ? JSON.parse(row.metadata)
+            : {};
+        await this.queries.messages.updateById(id, {
+            content: encryptedContent,
+            metadata: JSON.stringify({ ...existingMetadata, edited: true }),
+        });
+    }
+    async deleteMessage(id) {
+        // Delete any reactions that reference this message via metadata.originalMessageId
+        const reactions = await this.queries.messages.getReactionsByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        const toDelete = reactions.filter(row => {
+            if (!row.metadata)
+                return false;
+            try {
+                const meta = JSON.parse(row.metadata);
+                return meta?.originalMessageId === id;
+            }
+            catch {
+                return false;
+            }
+        });
+        for (const reaction of toDelete) {
+            await this.queries.messages.deleteById(reaction.id);
+        }
+        await this.queries.messages.deleteById(id);
+    }
+    async sendReaction(emoji, originalMessageDbId) {
+        const encryptedEmoji = await this.encryptContent(emoji);
+        const now = new Date();
+        const id = await this.queries.messages.insert({
+            ownerUserId: this.ownerUserId,
+            contactUserId: SELF_CONTACT_ID,
+            content: encryptedEmoji,
+            type: MessageType.REACTION,
+            direction: MessageDirection.OUTGOING,
+            status: MessageStatus.SENT,
+            timestamp: now,
+            metadata: JSON.stringify({ originalMessageId: originalMessageDbId }),
+        });
+        return { id, emoji, originalMessageId: originalMessageDbId };
+    }
+    async removeReaction(reactionId) {
+        await this.queries.messages.deleteById(reactionId);
+    }
+    async getReactions() {
+        const rows = await this.queries.messages.getReactionsByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        const result = [];
+        for (const row of rows) {
+            try {
+                const emoji = await this.decryptContent(row.content);
+                const meta = row.metadata ? JSON.parse(row.metadata) : null;
+                const originalMessageId = meta?.originalMessageId;
+                if (typeof originalMessageId === 'number') {
+                    result.push({ id: row.id, emoji, originalMessageId });
+                }
+            }
+            catch {
+                // Skip reactions that cannot be decrypted
+            }
+        }
+        return result;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260319090011",
+  "version": "0.0.2-dev.20260320093215",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",