Eventos de X Chat en tiempo real

import { Client } from '@xdevplatform/xdk';

// Creating a subscription requires user-context auth for the monitored user
const client = new Client({ accessToken: 'YOUR_OAUTH2_USER_TOKEN' });
await client.activity.createSubscription({
  event_type: 'chat.received',
  filter: { user_id: 'USER_ID_TO_MONITOR' },
});
// Stream: client.activity.stream() when available in your SDK version

import { createChat } from '@xdevplatform/chat-xdk';

const chat = await createChat({
  juiceboxConfig: JUICEBOX_CONFIG_JSON,
  getAuthToken: async (realmId) => getRealmToken(realmId),
});
await chat.unlock('YOUR_PASSCODE');
chat.setKeyVersion(SIGNING_KEY_VERSION);
const conversationKeys = new Map<string, Record<string, Uint8Array>>();

async function signingKeys(userId: string) {
  const resp = await apiClient.chat.getUserPublicKeys(userId, {
    publicKeyFields: [
      'public_key_version', 'public_key', 'signing_public_key', 'identity_public_key_signature',
    ],
  });
  return resp.data.map((r: any) => ({
    userId,
    publicKeyVersion: r.public_key_version,
    publicKey: r.signing_public_key,
    identityPublicKey: r.public_key,
    identityPublicKeySignature: r.identity_public_key_signature,
  }));
}

const data = body?.data ?? {};
if (data.event_type === 'chat.received' || data.event_type === 'chat.sent') {
  const p = data.payload ?? {};
  const cid = p.conversation_id as string;
  if (p.conversation_key_change_event) {
    conversationKeys.set(
      cid,
      chat.extractConversationKeys([p.conversation_key_change_event]).keys,
    );
  }
  const ev = chat.decryptEvent(
    p.encoded_event,
    conversationKeys.get(cid) ?? {},
    await signingKeys(p.sender_id),
  );
}

// chat: ChatCore or Chat, already unlocked / keys imported
if let Some(kc) = key_change.as_deref() {
    let extracted = chat.extract_conversation_keys(&[kc]);
    conv_keys.extend(extracted.keys);
}
// sender_signing_keys from GET /2/users/{sender_id}/public_keys
let event = chat.decrypt_event(&encoded_event, &conv_keys, &sender_signing_keys)?;

if keyChange != "" {
    extracted, _ := chat.ExtractConversationKeys([]string{keyChange})
    for v, k := range extracted.Keys {
        convKeys[v] = k
    }
}
event, err := chat.DecryptEvent(encodedEvent, convKeys, senderSigningKeys)
if err == nil && event.Type == "Message" {
    fmt.Println(event.AsMessage().Text())
}

if (!string.IsNullOrEmpty(keyChangeB64))
{
    var extracted = chat.ExtractConversationKeys(new[] { keyChangeB64 });
    foreach (var kv in extracted.Keys)
        convKeys[kv.Key] = kv.Value;
}
var evt = chat.DecryptEvent(encodedEvent, convKeys, senderSigningKeys);
if (evt.GetProperty("type").GetString() == "Message")
    Console.WriteLine(evt.GetProperty("content").GetProperty("text").GetString());

if (keyChangeB64 != null && !keyChangeB64.isEmpty()) {
    var extracted = chat.extractConversationKeys(List.of(keyChangeB64));
    convKeys.putAll(extracted.keys);
}
JsonNode evt = chat.decryptEvent(encodedEvent, convKeys, senderSigningKeys);
if ("Message".equals(evt.path("type").asText())) {
    System.out.println(evt.path("content").path("text").asText());
}