@michaelschnyder/teams-cli 0.1.0

package/dist/teams-client.js

@@ -0,0 +1,604 @@
+import { randomUUID } from "node:crypto";
+import { OUTLOOK_SEARCH_URL, TEAMS_WEB_ORIGIN } from "./constants.js";
+import { readJwtMetadata } from "./jwt.js";
+import { observedFetch } from "./diagnostics.js";
+export class TeamsApiError extends Error {
+    status;
+    tokenTarget;
+    constructor(status, message, tokenTarget) {
+        super(message);
+        this.status = status;
+        this.tokenTarget = tokenTarget;
+        this.name = "TeamsApiError";
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function booleanValue(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function nullableBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string" && entry.length > 0)
+        : [];
+}
+function firstEmailAddress(value) {
+    if (!Array.isArray(value))
+        return null;
+    for (const entry of value) {
+        if (typeof entry === "string" && entry.length > 0)
+            return entry;
+        if (!entry || typeof entry !== "object")
+            continue;
+        const email = entry;
+        const address = stringValue(email.Address) ?? stringValue(email.address) ??
+            stringValue(email.EmailAddress) ?? stringValue(email.emailAddress);
+        if (address)
+            return address;
+    }
+    return null;
+}
+function personIdentifiers(person) {
+    const mri = stringValue(person.mri) ?? stringValue(person.MRI);
+    const objectId = stringValue(person.objectId) ?? stringValue(person.ObjectId) ??
+        stringValue(person.Id) ?? stringValue(person.id);
+    const id = objectId ?? (mri?.startsWith("8:orgid:") ? mri.slice("8:orgid:".length) : mri);
+    return id ? { id, mri } : null;
+}
+function normalizePersonSummary(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const person = value;
+    const identifiers = personIdentifiers(person);
+    if (!identifiers)
+        return null;
+    return {
+        ...identifiers,
+        displayName: stringValue(person.displayName) ?? stringValue(person.DisplayName) ??
+            stringValue(person.friendlyName),
+        email: stringValue(person.email) ?? stringValue(person.Email) ??
+            stringValue(person.mail) ?? stringValue(person.Mail) ??
+            stringValue(person.emailAddress) ?? stringValue(person.EmailAddress) ??
+            firstEmailAddress(person.emailAddresses) ?? firstEmailAddress(person.EmailAddresses) ??
+            stringValue(person.userPrincipalName) ?? stringValue(person.UserPrincipalName),
+        jobTitle: stringValue(person.jobTitle) ?? stringValue(person.JobTitle),
+    };
+}
+function normalizePhones(value) {
+    if (!Array.isArray(value))
+        return [];
+    const phones = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const phone = entry;
+        const number = stringValue(phone.number) ?? stringValue(phone.Number);
+        if (!number)
+            continue;
+        phones.push({ type: stringValue(phone.type) ?? stringValue(phone.Type), number });
+    }
+    return phones;
+}
+function normalizePersonProfile(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const person = value;
+    const identifiers = personIdentifiers(person);
+    if (!identifiers)
+        return null;
+    const mail = stringValue(person.mail) ?? stringValue(person.Mail);
+    const userPrincipalName = stringValue(person.userPrincipalName) ??
+        stringValue(person.UserPrincipalName);
+    const email = stringValue(person.email) ?? stringValue(person.Email) ?? mail ?? userPrincipalName;
+    const skypeTeamsInfo = person.skypeTeamsInfo ?? person.SkypeTeamsInfo;
+    const teamsEnabled = skypeTeamsInfo && typeof skypeTeamsInfo === "object"
+        ? nullableBoolean(skypeTeamsInfo.isSkypeTeamsUser ??
+            skypeTeamsInfo.IsSkypeTeamsUser)
+        : null;
+    return {
+        ...identifiers,
+        displayName: stringValue(person.displayName) ?? stringValue(person.DisplayName) ??
+            stringValue(person.friendlyName),
+        givenName: stringValue(person.givenName) ?? stringValue(person.GivenName),
+        surname: stringValue(person.surname) ?? stringValue(person.Surname),
+        email,
+        mail,
+        userPrincipalName,
+        smtpAddresses: stringArray(person.smtpAddresses ?? person.SmtpAddresses),
+        jobTitle: stringValue(person.jobTitle) ?? stringValue(person.JobTitle),
+        department: stringValue(person.department) ?? stringValue(person.Department),
+        officeLocation: stringValue(person.physicalDeliveryOfficeName) ??
+            stringValue(person.PhysicalDeliveryOfficeName) ??
+            stringValue(person.userLocation) ?? stringValue(person.UserLocation),
+        mobile: stringValue(person.mobile) ?? stringValue(person.Mobile),
+        telephoneNumber: stringValue(person.telephoneNumber) ?? stringValue(person.TelephoneNumber),
+        phones: normalizePhones(person.phones ?? person.Phones),
+        tenantName: stringValue(person.tenantName) ?? stringValue(person.TenantName),
+        userType: stringValue(person.userType) ?? stringValue(person.UserType),
+        accountEnabled: nullableBoolean(person.accountEnabled ?? person.AccountEnabled),
+        teamsEnabled,
+    };
+}
+function normalizeParticipant(value) {
+    if (typeof value === "string") {
+        return { id: value, displayName: null, tenantId: null, objectId: null, role: null };
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const participant = value;
+    const id = stringValue(participant.mri) ?? stringValue(participant.MRI) ?? stringValue(participant.id);
+    if (!id)
+        return null;
+    return {
+        id,
+        displayName: stringValue(participant.friendlyName) ??
+            stringValue(participant.displayName) ??
+            stringValue(participant.DisplayName),
+        tenantId: stringValue(participant.tenantId) ?? stringValue(participant.TenantId),
+        objectId: stringValue(participant.objectId) ?? stringValue(participant.ExternalDirectoryObjectId),
+        role: stringValue(participant.role) ?? stringValue(participant.Role),
+    };
+}
+function normalizeChat(value, userNames = new Map()) {
+    if (!value || typeof value !== "object")
+        return null;
+    const chat = value;
+    const id = stringValue(chat.id) ?? stringValue(chat.ThreadId);
+    if (!id)
+        return null;
+    const rawParticipants = Array.isArray(chat.members)
+        ? chat.members
+        : Array.isArray(chat.ChatMembers)
+            ? chat.ChatMembers
+            : [];
+    // Search suggestions separate the matched person from the sampled chat roster.
+    // Put matches first so the reason for the server result remains visible.
+    const matchingParticipants = Array.isArray(chat.MatchingMembers) ? chat.MatchingMembers : [];
+    const participants = [...matchingParticipants, ...rawParticipants]
+        .map(normalizeParticipant)
+        .filter((participant) => participant !== null);
+    const seenParticipantIds = new Set();
+    const uniqueParticipants = participants.filter((participant) => {
+        if (seenParticipantIds.has(participant.id))
+            return false;
+        seenParticipantIds.add(participant.id);
+        return true;
+    });
+    for (const participant of uniqueParticipants) {
+        participant.displayName ??= userNames.get(participant.id) ?? null;
+    }
+    const explicitTitle = stringValue(chat.title) ?? stringValue(chat.Name);
+    const participantTitle = uniqueParticipants
+        .map((participant) => participant.displayName)
+        .filter((name) => name !== null)
+        .join(", ");
+    const lastActivity = stringValue(chat.LastMessageTime) ??
+        stringValue(chat.lastMessage?.composeTime) ??
+        stringValue(chat.lastMessage?.originalArrivalTime);
+    return {
+        id,
+        title: explicitTitle ?? (participantTitle || id),
+        type: stringValue(chat.chatType) ?? stringValue(chat.ThreadType),
+        oneOnOne: booleanValue(chat.isOneOnOne, false),
+        hidden: booleanValue(chat.hidden, false),
+        disabled: booleanValue(chat.isDisabled, false),
+        read: typeof chat.isRead === "boolean" ? chat.isRead : null,
+        lastActivity,
+        participants: uniqueParticipants,
+        participantCount: typeof chat.TotalChatMembersCount === "number"
+            ? chat.TotalChatMembersCount
+            : uniqueParticipants.length,
+    };
+}
+function normalizeChannels(value) {
+    if (!Array.isArray(value))
+        return [];
+    const channels = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const team = entry;
+        const teamId = stringValue(team.id) ?? stringValue(team.threadId);
+        const teamName = stringValue(team.name) ?? stringValue(team.displayName) ?? teamId;
+        if (!teamId || !teamName || !Array.isArray(team.channels))
+            continue;
+        for (const item of team.channels) {
+            if (!item || typeof item !== "object")
+                continue;
+            const channel = item;
+            const id = stringValue(channel.id) ?? stringValue(channel.threadId);
+            const name = stringValue(channel.name) ?? stringValue(channel.displayName) ?? id;
+            if (!id || !name)
+                continue;
+            channels.push({
+                id,
+                name,
+                description: stringValue(channel.description),
+                team: { id: teamId, name: teamName },
+            });
+        }
+    }
+    return channels;
+}
+function normalizeMessage(value, fallbackChatId) {
+    if (!value || typeof value !== "object")
+        return null;
+    const message = value;
+    const id = stringValue(message.id);
+    if (!id)
+        return null;
+    const properties = message.properties && typeof message.properties === "object" &&
+        !Array.isArray(message.properties)
+        ? message.properties
+        : {};
+    const numericOrString = (input) => typeof input === "number" || typeof input === "string" ? input : null;
+    return {
+        id,
+        chatId: stringValue(message.conversationid) ?? fallbackChatId,
+        sequenceId: numericOrString(message.sequenceId),
+        version: numericOrString(message.version),
+        type: stringValue(message.type),
+        messageType: stringValue(message.messagetype),
+        contentType: stringValue(message.contenttype),
+        content: typeof message.content === "string" ? message.content : null,
+        sender: {
+            id: stringValue(message.from),
+            displayName: stringValue(message.imdisplayname),
+        },
+        composedAt: stringValue(message.composetime),
+        originalArrivalAt: stringValue(message.originalarrivaltime),
+        properties,
+    };
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(encoded) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("Invalid paging cursor");
+    }
+    if (!parsed || typeof parsed !== "object")
+        throw new Error("Invalid paging cursor");
+    const cursor = parsed;
+    if (cursor.version !== 1 || (cursor.kind !== "chats" && cursor.kind !== "messages")) {
+        throw new Error("Unsupported paging cursor");
+    }
+    if (typeof cursor.tenantId !== "string")
+        throw new Error("Invalid paging cursor");
+    if (cursor.kind === "chats" && typeof cursor.syncToken === "string")
+        return cursor;
+    if (cursor.kind === "messages" &&
+        typeof cursor.chatId === "string" &&
+        typeof cursor.url === "string")
+        return cursor;
+    throw new Error("Invalid paging cursor");
+}
+function requireCursorTenant(cursor, session) {
+    if (cursor.tenantId !== session.tenantId) {
+        throw new Error("Paging cursor belongs to a different Teams tenant");
+    }
+}
+function csaUrl(updates) {
+    const url = new URL(`/api/csa/api/v1/teams/users/me${updates ? "/updates" : ""}`, TEAMS_WEB_ORIGIN);
+    url.searchParams.set("isPrefetch", "false");
+    url.searchParams.set("enableMembershipSummary", "true");
+    url.searchParams.set("supportsAdditionalSystemGeneratedFolders", "true");
+    url.searchParams.set("supportsSliceItems", "true");
+    return url;
+}
+async function jsonResponse(response, operation, tokenTarget) {
+    const raw = await response.text();
+    if (!response.ok) {
+        throw new TeamsApiError(response.status, `${operation} failed (${response.status} ${response.statusText})`, tokenTarget);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${operation} returned invalid JSON`);
+    }
+}
+export async function listChats(session, cursorValue, fetchImplementation = fetch) {
+    let syncToken;
+    if (cursorValue) {
+        const cursor = decodeCursor(cursorValue);
+        if (cursor.kind !== "chats")
+            throw new Error("Expected a chat paging cursor");
+        requireCursorTenant(cursor, session);
+        syncToken = cursor.syncToken;
+    }
+    const response = await observedFetch(fetchImplementation, csaUrl(Boolean(syncToken)), {
+        headers: {
+            authorization: `Bearer ${session.chatToken.value}`,
+            "x-skypetoken": session.skypeToken.value,
+            ...(syncToken ? { "x-ms-synctoken": syncToken } : {}),
+            accept: "application/json",
+        },
+    });
+    const payload = await jsonResponse(response, "Chat discovery", "chat");
+    const userNames = new Map();
+    if (Array.isArray(payload.users)) {
+        for (const value of payload.users) {
+            if (!value || typeof value !== "object")
+                continue;
+            const user = value;
+            const id = stringValue(user.mri) ?? stringValue(user.MRI);
+            const name = stringValue(user.displayName) ?? stringValue(user.DisplayName) ??
+                stringValue(user.email) ?? stringValue(user.userPrincipalName);
+            if (id && name)
+                userNames.set(id, name);
+        }
+    }
+    const chats = Array.isArray(payload.chats)
+        ? payload.chats
+            .map((chat) => normalizeChat(chat, userNames))
+            .filter((chat) => chat !== null)
+        : [];
+    const nextSyncToken = stringValue(payload.metadata?.syncToken);
+    const nextCursor = payload.metadata?.hasMoreChats === true && nextSyncToken
+        ? encodeCursor({ version: 1, kind: "chats", tenantId: session.tenantId, syncToken: nextSyncToken })
+        : null;
+    return { chats, page: { nextCursor } };
+}
+export async function searchPeople(session, query, fetchImplementation = fetch) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        throw new Error("Person search query must not be empty");
+    const url = new URL(OUTLOOK_SEARCH_URL);
+    url.searchParams.set("scenario", "powerbar");
+    const response = await observedFetch(fetchImplementation, url, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${session.searchToken.value}`,
+            "content-type": "application/json",
+            accept: "application/json",
+        },
+        body: JSON.stringify({
+            EntityRequests: [{
+                    Query: {
+                        QueryString: trimmed,
+                        DisplayQueryString: trimmed,
+                        NormalizedQueryString: trimmed,
+                    },
+                    EntityType: "People",
+                    Size: 25,
+                }],
+            Scenario: { Name: "powerbar", Dimensions: [] },
+            Cvid: randomUUID(),
+            AppName: "Microsoft Teams",
+            LogicalId: randomUUID(),
+            dataSource: "personScoped",
+        }),
+    });
+    const payload = await jsonResponse(response, "People search", "search");
+    const group = payload.Groups?.find((candidate) => candidate.Type === "People");
+    const people = Array.isArray(group?.Suggestions)
+        ? group.Suggestions
+            .map(normalizePersonSummary)
+            .filter((person) => person !== null)
+        : [];
+    return { query: trimmed, people };
+}
+function middleTierBaseUrl(session) {
+    if (!session.endpoints.middleTier) {
+        return new URL(`/api/mt/${encodeURIComponent(session.region)}/beta/`, TEAMS_WEB_ORIGIN);
+    }
+    const url = new URL(session.endpoints.middleTier);
+    if (url.protocol !== "https:" ||
+        (url.hostname !== "teams.microsoft.com" && !url.hostname.endsWith(".teams.microsoft.com"))) {
+        throw new Error("Stored Teams middle-tier endpoint is not trusted");
+    }
+    const path = url.pathname.replace(/\/+$/, "");
+    url.pathname = `${path.endsWith("/beta") ? path : `${path}/beta`}/`;
+    url.search = "";
+    url.hash = "";
+    return url;
+}
+function personUrl(session, identifier, suffix = "") {
+    const trimmed = identifier.trim();
+    if (!trimmed)
+        throw new Error("Person identifier must not be empty");
+    const url = new URL(`users/${encodeURIComponent(trimmed)}/${suffix}`, middleTierBaseUrl(session));
+    url.searchParams.set("isMailAddress", String(trimmed.includes("@")));
+    url.searchParams.set("enableGuest", "true");
+    url.searchParams.set("includeIBBarredUsers", "true");
+    url.searchParams.set("skypeTeamsInfo", "true");
+    return url;
+}
+export async function getPerson(session, identifier, fetchImplementation = fetch) {
+    const response = await observedFetch(fetchImplementation, personUrl(session, identifier), {
+        headers: {
+            authorization: `Bearer ${session.accessToken.value}`,
+            accept: "application/json",
+        },
+    });
+    const payload = await jsonResponse(response, "Person lookup", "access");
+    const person = normalizePersonProfile(payload.value ?? payload);
+    if (!person)
+        throw new Error("Person lookup returned no person");
+    return { person };
+}
+function decodeBase64Image(raw) {
+    const encoded = raw.toString("utf8").trim();
+    if (!encoded || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1) {
+        throw new Error("Person image lookup returned invalid image data");
+    }
+    const decoded = Buffer.from(encoded.padEnd(Math.ceil(encoded.length / 4) * 4, "="), "base64");
+    if (!decoded.length)
+        throw new Error("Person image lookup returned an empty image");
+    return decoded;
+}
+export async function getPersonImage(session, identifier, size = "max", fetchImplementation = fetch) {
+    const url = personUrl(session, identifier, "profilepicture");
+    url.searchParams.set("displayname", identifier.trim());
+    url.searchParams.set("size", `HR${size === "max" ? "648" : size}x${size === "max" ? "648" : size}`);
+    const response = await observedFetch(fetchImplementation, url, {
+        headers: { authorization: `Bearer ${session.accessToken.value}` },
+    });
+    if (response.status === 404) {
+        throw new TeamsApiError(404, `No profile image found for: ${identifier}`, "access");
+    }
+    if (!response.ok) {
+        throw new TeamsApiError(response.status, `Person image lookup failed (${response.status} ${response.statusText})`, "access");
+    }
+    const raw = Buffer.from(await response.arrayBuffer());
+    if (!raw.length)
+        throw new Error("Person image lookup returned an empty image");
+    const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim();
+    return contentType?.startsWith("image/")
+        ? { data: raw, contentType }
+        : { data: decodeBase64Image(raw), contentType: "image/jpeg" };
+}
+async function discoveryPayload(session, fetchImplementation) {
+    const response = await observedFetch(fetchImplementation, csaUrl(false), {
+        headers: {
+            authorization: `Bearer ${session.chatToken.value}`,
+            "x-skypetoken": session.skypeToken.value,
+            accept: "application/json",
+        },
+    });
+    return await jsonResponse(response, "Teams discovery", "chat");
+}
+export async function getChat(session, chatId, fetchImplementation = fetch) {
+    let cursor;
+    do {
+        const result = await listChats(session, cursor, fetchImplementation);
+        const chat = result.chats.find((candidate) => candidate.id === chatId);
+        if (chat)
+            return { chat };
+        cursor = result.page.nextCursor ?? undefined;
+    } while (cursor);
+    throw new Error(`Chat not found: ${chatId}`);
+}
+export async function listChannels(session, fetchImplementation = fetch) {
+    const payload = await discoveryPayload(session, fetchImplementation);
+    return { channels: normalizeChannels(payload.teams) };
+}
+export async function getChannel(session, channelId, fetchImplementation = fetch) {
+    const result = await listChannels(session, fetchImplementation);
+    const channel = result.channels.find((candidate) => candidate.id === channelId);
+    if (!channel)
+        throw new Error(`Channel not found: ${channelId}`);
+    return { channel };
+}
+function messagePath(chatId) {
+    return `/v1/users/ME/conversations/${encodeURIComponent(chatId)}/messages`;
+}
+function initialMessageUrl(session, chatId, options) {
+    const url = new URL(messagePath(chatId), session.endpoints.chatService);
+    url.searchParams.set("view", "msnp24Equivalent|supportsMessageProperties");
+    url.searchParams.set("pageSize", String(options.pageSize ?? 200));
+    url.searchParams.set("startTime", "1");
+    return url;
+}
+function continuedMessageUrl(session, chatId, encoded) {
+    const cursor = decodeCursor(encoded);
+    if (cursor.kind !== "messages")
+        throw new Error("Expected a message paging cursor");
+    requireCursorTenant(cursor, session);
+    if (cursor.chatId !== chatId)
+        throw new Error("Paging cursor belongs to a different chat");
+    const url = new URL(cursor.url);
+    const endpoint = new URL(session.endpoints.chatService);
+    if (url.protocol !== "https:" || url.origin !== endpoint.origin) {
+        throw new Error("Message paging cursor points to an untrusted host");
+    }
+    if (decodeURIComponent(url.pathname) !== decodeURIComponent(messagePath(chatId))) {
+        throw new Error("Message paging cursor has an invalid path");
+    }
+    return url;
+}
+export async function listMessages(session, target, options, fetchImplementation = fetch) {
+    const url = options.cursor
+        ? continuedMessageUrl(session, target.id, options.cursor)
+        : initialMessageUrl(session, target.id, options);
+    const response = await observedFetch(fetchImplementation, url, {
+        headers: {
+            authentication: `skypetoken=${session.skypeToken.value}`,
+            accept: "application/json",
+        },
+    });
+    const payload = await jsonResponse(response, "Message listing", "skype");
+    const messages = Array.isArray(payload.messages)
+        ? payload.messages
+            .map((message) => normalizeMessage(message, target.id))
+            .filter((message) => message !== null)
+        : [];
+    const backwardLink = stringValue(payload._metadata?.backwardLink);
+    const nextCursor = backwardLink
+        ? encodeCursor({
+            version: 1,
+            kind: "messages",
+            tenantId: session.tenantId,
+            chatId: target.id,
+            url: backwardLink,
+        })
+        : null;
+    return { target, messages, page: { nextCursor } };
+}
+export async function getMessage(session, target, messageId, fetchImplementation = fetch) {
+    const url = new URL(`${messagePath(target.id)}/${encodeURIComponent(messageId)}`, session.endpoints.chatService);
+    const response = await observedFetch(fetchImplementation, url, {
+        headers: {
+            authentication: `skypetoken=${session.skypeToken.value}`,
+            accept: "application/json",
+        },
+    });
+    const payload = await jsonResponse(response, "Message lookup", "skype");
+    const message = normalizeMessage(payload.message ?? payload, target.id);
+    if (!message)
+        throw new Error("Message lookup returned no message");
+    return { target, message };
+}
+export async function sendMessage(session, target, content, requestId, sessionId, authorize, fetchImplementation = fetch) {
+    const plainTextAsHtml = content
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;")
+        .replaceAll(/\r?\n/g, "<br>");
+    const displayName = readJwtMetadata(session.accessToken.value).name ?? "";
+    await authorize();
+    const response = await observedFetch(fetchImplementation, new URL(messagePath(target.id), session.endpoints.chatService), {
+        method: "POST",
+        headers: {
+            authentication: `skypetoken=${session.skypeToken.value}`,
+            "x-ms-session-id": sessionId,
+            "content-type": "application/json",
+            accept: "application/json",
+        },
+        body: JSON.stringify({
+            clientmessageid: requestId,
+            content: `<p>${plainTextAsHtml}</p>`,
+            contenttype: "text",
+            messagetype: "RichText/Html",
+            amsreferences: [],
+            imdisplayname: displayName,
+            properties: { importance: "", subject: "" },
+        }),
+    });
+    if (!response.ok) {
+        throw new TeamsApiError(response.status, `Message send failed (${response.status} ${response.statusText})`, "skype");
+    }
+    const raw = await response.text();
+    if (!raw.trim())
+        return { target, message: null };
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        return { target, message: null };
+    }
+    const message = normalizeMessage(payload.message ?? payload, target.id);
+    return { target, message };
+}