@sendbird/cli 0.0.0-stage → 0.4.0

package/dist/sdk-runtime.js

@@ -0,0 +1,685 @@
+import { message, user } from "./sdk-dto.js";
+export { message, user } from "./sdk-dto.js";
+import { readQueryPage } from "./sdk-query.js";
+export { readQueryPage } from "./sdk-query.js";
+import { messageOptions, runProUser, runProChannel, } from "./sdk-pro-runtime.js";
+import { CliError } from "./core.js";
+import { installNodeFileReader } from "./sdk-node-file-reader.js";
+export async function makeSdk(job) {
+    await import("@sendbird/chat/node");
+    installNodeFileReader();
+    const [{ default: SendbirdChat, LogLevel }, { GroupChannelModule }, { OpenChannelModule }, { PollModule },] = await Promise.all([
+        import("@sendbird/chat"),
+        import("@sendbird/chat/groupChannel"),
+        import("@sendbird/chat/openChannel"),
+        import("@sendbird/chat/poll"),
+    ]);
+    return SendbirdChat.init({
+        appId: job.appId,
+        newInstance: true,
+        localCacheEnabled: false,
+        logLevel: LogLevel.NONE,
+        debugMode: false,
+        appStateToggleEnabled: false,
+        customApiHost: job.apiHost,
+        customWebSocketHost: job.wsHost,
+        modules: [
+            new GroupChannelModule(),
+            new OpenChannelModule(),
+            new PollModule(),
+        ],
+    });
+}
+function scheduledMessage(m) {
+    const info = m.scheduledInfo;
+    if (!info)
+        throw new CliError("E_SCHEMA", "SDK did not return scheduled message information", 8);
+    return {
+        scheduled_message_id: info.scheduledMessageId,
+        scheduled_at: info.scheduledAt,
+        channel_url: m.channelUrl,
+        ...(m.isUserMessage() ? { message: m.message } : {}),
+    };
+}
+function channel(c) {
+    return {
+        channel_url: c.url,
+        name: c.name,
+        type: c.isOpenChannel() ? "open" : c.isSuper ? "supergroup" : "group",
+        ...(c.isGroupChannel()
+            ? {
+                unread_message_count: c.unreadMessageCount,
+                member_count: c.memberCount,
+            }
+            : { participant_count: c.participantCount }),
+    };
+}
+function myGroupChannel(c) {
+    return {
+        channel_url: c.url,
+        name: c.name,
+        type: c.isSuper ? "supergroup" : "group",
+        member_count: c.memberCount,
+        last_message_id: c.lastMessage?.messageId ?? null,
+        sdk_unread_message_count_snapshot: c.lastMessage
+            ? c.unreadMessageCount
+            : null,
+        sdk_unread_mention_count_snapshot: c.lastMessage
+            ? c.unreadMentionCount
+            : null,
+        my_member_state: c.myMemberState,
+        my_count_preference: c.myCountPreference,
+    };
+}
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+function acknowledged(handler) {
+    return new Promise((resolve, reject) => {
+        handler.onSucceeded(resolve);
+        handler.onFailed(reject);
+    });
+}
+export async function runSdk(job, emit = () => { }, signal, factory = makeSdk) {
+    const sb = await factory(job);
+    let c;
+    let entered = false;
+    let typing = false;
+    let handlerKey;
+    const checkAbort = () => {
+        if (signal?.aborted)
+            throw new CliError("E_INTERRUPTED", "SDK operation interrupted before its next action", 130);
+    };
+    const group = () => {
+        if (!c?.isGroupChannel())
+            throw new CliError("E_CHANNEL_TYPE", "This operation requires a Group channel", 2);
+        return c;
+    };
+    const currentMessage = async () => {
+        const m = await sb.message.getMessage({
+            channelUrl: c.url,
+            channelType: c.channelType,
+            messageId: Number(job.params.message_id),
+            includeMetaArray: true,
+            includeReactions: true,
+            includeThreadInfo: true,
+            includeParentMessageInfo: true,
+        });
+        checkAbort();
+        if (!m)
+            throw new CliError("E_NOT_FOUND", "Message not found", 3);
+        if (!("messageId" in m) || m.messageId !== Number(job.params.message_id))
+            throw new CliError("E_SCHEMA", "Server returned a different message ID", 8);
+        if (m.channelUrl !== c.url)
+            throw new CliError("E_SCHEMA", "Message belongs to a different channel", 8);
+        return m;
+    };
+    const b = job.body;
+    let preparedOptions;
+    const common = () => ({
+        ...preparedOptions,
+        ...(b.custom_type !== undefined
+            ? { customType: b.custom_type }
+            : {}),
+        ...(b.data !== undefined ? { data: b.data } : {}),
+        ...(b.parent_message_id !== undefined
+            ? { parentMessageId: b.parent_message_id }
+            : {}),
+    });
+    try {
+        checkAbort();
+        const who = await sb.connect(job.actor, job.token);
+        checkAbort();
+        if (who.userId !== job.actor)
+            throw new CliError("E_AUTH", "Connected user does not match requested identity", 4);
+        preparedOptions = await messageOptions(b);
+        checkAbort();
+        const proUserResult = await runProUser(job, sb, who, checkAbort);
+        if (proUserResult !== undefined)
+            return proUserResult;
+        if (job.action === "status")
+            return { connected: true, app_id: job.appId, user: user(who) };
+        if (job.action === "emoji-list") {
+            const catalog = await sb.getAllEmoji();
+            checkAbort();
+            return {
+                emoji_hash: catalog.emojiHash,
+                emojis: catalog.emojiCategories.flatMap((category) => category.emojis.map((emoji) => ({
+                    key: emoji.key,
+                    url: emoji.url,
+                    category_id: category.id,
+                    category_name: category.name,
+                }))),
+            };
+        }
+        if (job.action === "my-channels-list") {
+            const type = String(b.type ?? "all");
+            const memberState = String(b.member_state ?? "all");
+            const params = {
+                limit: Number(b.limit),
+                // Staging can report a received message while the channel list still
+                // has last_message=null. Excluding "empty" channels then drops the room.
+                includeEmpty: true,
+                superChannelFilter: (type === "supergroup"
+                    ? "super"
+                    : type === "group"
+                        ? "nonsuper"
+                        : "all"),
+                myMemberStateFilter: (memberState === "joined"
+                    ? "joined_only"
+                    : memberState === "invited"
+                        ? "invited_only"
+                        : "all"),
+            };
+            const q = sb.groupChannel.createMyGroupChannelListQuery(params);
+            const result = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+            return {
+                channels: result.items.map(myGroupChannel),
+                has_more: result.has_more,
+                page: result.page,
+                next_page: result.next_page,
+                pagination: result.pagination,
+                unread_count_note: "Per-channel SDK counts are unknown when last_message_id is null and may disagree with the aggregate; use chat sdk channel my unread for the total.",
+                filters: {
+                    type,
+                    member_state: memberState,
+                },
+            };
+        }
+        if (job.action === "my-channels-unread") {
+            const type = String(b.type ?? "all");
+            return {
+                type,
+                unread_message_count: await sb.groupChannel.getTotalUnreadMessageCount({
+                    superChannelFilter: (type === "supergroup"
+                        ? "super"
+                        : type === "group"
+                            ? "nonsuper"
+                            : "all"),
+                }),
+            };
+        }
+        if (job.action === "invitation-get") {
+            const preference = await sb.getChannelInvitationPreference();
+            return { auto_accept: preference.autoAccept };
+        }
+        if (job.action === "invitation-set") {
+            const preference = await sb.setChannelInvitationPreference(Boolean(b.auto_accept));
+            return { auto_accept: preference.autoAccept };
+        }
+        if (job.action === "push-get")
+            return { option: await sb.getPushTriggerOption() };
+        if (job.action === "push-set")
+            return {
+                option: await sb.setPushTriggerOption(String(b.option)),
+            };
+        if (job.action === "snooze-get")
+            return await sb.getSnoozePeriod();
+        if (job.action === "snooze-set") {
+            // Some backends reject the SDK's default 0/0 interval even when disabling.
+            // Preserve the current valid window instead of retrying a rejected write.
+            if (b.enabled === false &&
+                b.start_at === undefined &&
+                b.end_at === undefined) {
+                const previous = await sb.getSnoozePeriod();
+                checkAbort();
+                if (!previous.isSnoozeOn)
+                    return previous;
+                return await sb.setSnoozePeriod(false, previous.startTs, previous.endTs);
+            }
+            return await sb.setSnoozePeriod(Boolean(b.enabled), b.start_at, b.end_at);
+        }
+        c =
+            job.params.type === "open"
+                ? await sb.openChannel.getChannel(String(job.params.id))
+                : await sb.groupChannel.getChannel(String(job.params.id));
+        checkAbort();
+        if (c.url !== job.params.id)
+            throw new CliError("E_SCHEMA", "SDK returned a different channel URL", 8);
+        if (c.isGroupChannel() && c.isSuper !== (job.params.type === "supergroup"))
+            throw new CliError("E_CHANNEL_TYPE", "Channel does not match --type; use group or supergroup explicitly", 2);
+        if (c.isOpenChannel()) {
+            await c.enter();
+            entered = true;
+        }
+        checkAbort();
+        const proChannelResult = await runProChannel(job, sb, c, checkAbort, currentMessage);
+        if (proChannelResult !== undefined)
+            return proChannelResult;
+        switch (job.action) {
+            case "send":
+                return message(await acknowledged(c.sendUserMessage({ ...common(), message: String(b.message) })));
+            case "file": {
+                let file;
+                if (b.file) {
+                    const { readFile, stat } = await import("node:fs/promises");
+                    const { basename } = await import("node:path");
+                    const info = await stat(String(b.file));
+                    if (info.size > 25 * 1024 * 1024)
+                        throw new CliError("E_FILE", "Local file exceeds CLI upload limit (25 MiB)", 2);
+                    file = new File([await readFile(String(b.file))], String(b.file_name ?? basename(String(b.file))), { type: String(b.mime_type ?? "application/octet-stream") });
+                }
+                checkAbort();
+                return message(await acknowledged(c.sendFileMessage({
+                    ...common(),
+                    ...(file ? { file } : { fileUrl: String(b.file_url) }),
+                    fileName: b.file_name,
+                    mimeType: b.mime_type,
+                    thumbnailSizes: b.thumbnail_sizes?.map((s) => ({ maxWidth: s.width, maxHeight: s.height })),
+                })));
+            }
+            case "get":
+                return message(await currentMessage());
+            case "list": {
+                const params = {
+                    prevResultSize: Number(b.limit),
+                    nextResultSize: 0,
+                    isInclusive: false,
+                    includeMetaArray: true,
+                    includeReactions: true,
+                    includeThreadInfo: true,
+                    includeParentMessageInfo: true,
+                };
+                const items = b.before_id !== undefined
+                    ? await c.getMessagesByMessageId(Number(b.before_id), params)
+                    : await c.getMessagesByTimestamp(Number(b.before ?? Date.now()), params);
+                const oldest = [...items].sort((a, z) => a.createdAt - z.createdAt || a.messageId - z.messageId)[0];
+                return {
+                    messages: items.map(message),
+                    next_before_id: oldest?.messageId ?? null,
+                    pagination: "Use --before-id for the next older page; do not mix with --before.",
+                };
+            }
+            case "update":
+                return message(await c.updateUserMessage(Number(job.params.message_id), {
+                    ...common(),
+                    message: String(b.message),
+                }));
+            case "delete":
+                await c.deleteMessage(await currentMessage());
+                return { deleted: true, message_id: job.params.message_id };
+            case "reply": {
+                const parent = await currentMessage();
+                if (parent.parentMessageId)
+                    throw new CliError("E_VALIDATION", "Reply using the root parent message ID", 2);
+                return message(await acknowledged(c.sendUserMessage({
+                    message: String(b.message),
+                    ...common(),
+                    parentMessageId: parent.messageId,
+                    isReplyToChannel: true,
+                })));
+            }
+            case "thread": {
+                const parent = await currentMessage();
+                if (!parent.isUserMessage() && !parent.isFileMessage())
+                    throw new CliError("E_VALIDATION", "Threads require a text or file parent", 2);
+                const result = await parent.getThreadedMessagesByTimestamp(Number(b.before ?? Date.now()), {
+                    prevResultSize: Number(b.limit),
+                    nextResultSize: 0,
+                    isInclusive: Boolean(b.inclusive),
+                    includeMetaArray: true,
+                    includeReactions: true,
+                });
+                // A structurally valid SDK response is insufficient: a backend may
+                // return a reply as the parent. Do not hide this by substituting IDs.
+                if (result.parentMessage.messageId !== parent.messageId ||
+                    result.parentMessage.channelUrl !== c.url ||
+                    result.threadedMessages.some((m) => m.parentMessageId !== parent.messageId || m.channelUrl !== c.url))
+                    throw new CliError("E_SCHEMA", "Thread response does not match the requested parent message", 8, {
+                        requested_message_id: parent.messageId,
+                        returned_parent_message_id: result.parentMessage.messageId,
+                    });
+                return {
+                    parent: message(result.parentMessage),
+                    messages: result.threadedMessages.map(message),
+                    next_before: result.threadedMessages.length
+                        ? Math.min(...result.threadedMessages.map((m) => m.createdAt))
+                        : null,
+                    pagination: "Inclusive timestamp pages can overlap; deduplicate by message_id. If the boundary does not advance, increase --limit (max 100).",
+                };
+            }
+            case "reaction-add":
+            case "reaction-remove": {
+                const m = await currentMessage();
+                const result = job.action === "reaction-add"
+                    ? await c.addReaction(m, String(b.key))
+                    : await c.deleteReaction(m, String(b.key));
+                return {
+                    message_id: result.messageId,
+                    key: result.key,
+                    user_id: result.userId,
+                    operation: result.operation,
+                };
+            }
+            case "receipts": {
+                const m = await currentMessage();
+                const g = group();
+                return {
+                    message_id: m.messageId,
+                    unread_count: g.getUnreadMemberCount(m),
+                    undelivered_count: g.getUndeliveredMemberCount(m),
+                    read_members: g.getReadMembers(m).map(user),
+                    unread_members: g.getUnreadMembers(m).map(user),
+                };
+            }
+            case "pin":
+                await c.pinMessage(Number(job.params.message_id));
+                return { pinned: true, message_id: job.params.message_id };
+            case "unpin":
+                await c.unpinMessage(Number(job.params.message_id));
+                return { pinned: false, message_id: job.params.message_id };
+            case "join":
+                await group().join(b.access_code);
+                return channel(c);
+            case "leave": {
+                const channelUrl = c.url;
+                await group().leave();
+                return { left: true, channel_url: channelUrl };
+            }
+            case "accept":
+                await group().acceptInvitation(b.access_code);
+                return channel(c);
+            case "decline": {
+                const channelUrl = c.url;
+                const target = group();
+                // Admin-originated invitations can have no inviter. SDK 4.22.13's
+                // decline-event decoder throws on that null user. This one-shot REST
+                // operation needs the authenticated session, not an event stream.
+                // The public API preserves currentUser/cache; never swallow errors or
+                // retry the mutation to work around the decoder failure.
+                await sb.disconnectWebSocket();
+                checkAbort();
+                await target.declineInvitation();
+                return { declined: true, channel_url: channelUrl };
+            }
+            case "participants": {
+                if (!c.isOpenChannel())
+                    throw new CliError("E_CHANNEL_TYPE", "Open channel required", 2);
+                const q = c.createParticipantListQuery({ limit: Number(b.limit) });
+                const page = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+                return {
+                    participants: page.items.map(user),
+                    has_more: page.has_more,
+                    page: page.page,
+                    next_page: page.next_page,
+                    pagination: page.pagination,
+                };
+            }
+            case "members-list": {
+                const q = group().createMemberListQuery({ limit: Number(b.limit) });
+                const page = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+                return {
+                    members: page.items.map(user),
+                    has_more: page.has_more,
+                    page: page.page,
+                    next_page: page.next_page,
+                    pagination: page.pagination,
+                };
+            }
+            case "members-invite":
+                return channel(await group().inviteWithUserIds(b.user_ids));
+            case "count-preference-get": {
+                const g = group();
+                return {
+                    channel_url: g.url,
+                    type: g.isSuper ? "supergroup" : "group",
+                    preference: g.myCountPreference,
+                };
+            }
+            case "count-preference-set": {
+                const g = group();
+                const preference = await g.setMyCountPreference(String(b.preference));
+                return {
+                    channel_url: g.url,
+                    type: g.isSuper ? "supergroup" : "group",
+                    preference,
+                };
+            }
+            case "typing-users": {
+                const g = group();
+                if (g.isSuper)
+                    throw new CliError("E_CHANNEL_TYPE", "Typing users are available only in regular Group channels", 2);
+                return { channel_url: g.url, users: g.getTypingUsers().map(user) };
+            }
+            case "counters-get":
+                return {
+                    counters: await c.getMetaCounters(b.keys),
+                };
+            case "counters-create":
+                return {
+                    counters: await c.createMetaCounters(b.counters),
+                };
+            case "counters-increase":
+                return {
+                    counters: await c.increaseMetaCounters(b.counters),
+                };
+            case "counters-decrease":
+                return {
+                    counters: await c.decreaseMetaCounters(b.counters),
+                };
+            case "pins-list": {
+                const q = group().createPinnedMessageListQuery({
+                    limit: Number(b.limit),
+                    includeMetaArray: true,
+                    includeReactions: true,
+                    includeThreadInfo: true,
+                    includeParentMessageInfo: true,
+                    includePollDetails: true,
+                });
+                const page = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+                return {
+                    messages: page.items.flatMap((pin) => pin.message ? [message(pin.message)] : []),
+                    has_more: page.has_more,
+                    page: page.page,
+                    next_page: page.next_page,
+                    pagination: page.pagination,
+                };
+            }
+            case "channel-push-get":
+                return { option: await group().getMyPushTriggerOption() };
+            case "channel-push-set":
+                return {
+                    option: await group().setMyPushTriggerOption(String(b.option)),
+                };
+            case "hide":
+                return channel(await group().hide({
+                    hidePreviousMessages: Boolean(b.hide_previous_messages),
+                }));
+            case "unhide":
+                return channel(await group().unhide());
+            case "reset-history":
+                return channel(await group().resetMyHistory());
+            case "scheduled-create":
+                return scheduledMessage(await acknowledged(group().createScheduledUserMessage({
+                    message: String(b.message),
+                    scheduledAt: Number(b.scheduled_at),
+                    ...common(),
+                })));
+            case "scheduled-list": {
+                const q = sb.groupChannel.createScheduledMessageListQuery({
+                    channelUrl: c.url,
+                    limit: Number(b.limit),
+                    scheduledStatus: b.status && b.status !== "all"
+                        ? [b.status]
+                        : undefined,
+                });
+                const page = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+                return {
+                    messages: page.items.map(scheduledMessage),
+                    has_more: page.has_more,
+                    page: page.page,
+                    next_page: page.next_page,
+                    status_filter: b.status ?? "all",
+                    pagination: page.pagination,
+                };
+            }
+            case "scheduled-cancel":
+                await group().cancelScheduledMessage(Number(job.params.message_id));
+                return { canceled: true, message_id: Number(job.params.message_id) };
+            case "scheduled-send-now":
+                await group().sendScheduledMessageNow(Number(job.params.message_id));
+                return { sent: true, message_id: Number(job.params.message_id) };
+            case "translate": {
+                const m = await currentMessage();
+                if (!m.isUserMessage())
+                    throw new CliError("E_VALIDATION", "Only user messages can be translated", 2);
+                const translated = await c.translateUserMessage(m, b.languages);
+                return {
+                    ...message(translated),
+                    translations: translated.translations,
+                };
+            }
+            case "message-changes":
+                return await c.getMessageChangeLogsSinceTimestamp(Number(b.since));
+            case "poll-list": {
+                const q = group().createPollListQuery(Number(b.limit));
+                const page = await readQueryPage(q, Number(b.page ?? 1), checkAbort);
+                return {
+                    polls: page.items.map((poll) => ({ poll_id: poll.id, ...poll })),
+                    has_more: page.has_more,
+                    page: page.page,
+                    next_page: page.next_page,
+                    pagination: page.pagination,
+                };
+            }
+            case "poll-vote":
+                return await group().votePoll(Number(b.poll_id), b.option_ids);
+            case "poll-option-add":
+                return await group().addPollOption(Number(b.poll_id), String(b.option));
+            case "operator-add":
+                await c.addOperators(b.user_ids);
+                return { updated: true };
+            case "operator-remove":
+                await c.removeOperators(b.user_ids);
+                return { updated: true };
+            case "mute":
+                if (b.user_id)
+                    await c.muteUserWithUserId(String(b.user_id), b.seconds, b.description);
+                return { updated: true };
+            case "unmute":
+                await c.unmuteUserWithUserId(String(b.user_id));
+                return { updated: true };
+            case "ban":
+                await c.banUserWithUserId(String(b.user_id), b.seconds, b.description);
+                return { updated: true };
+            case "unban":
+                await c.unbanUserWithUserId(String(b.user_id));
+                return { updated: true };
+            case "freeze":
+                if (b.frozen)
+                    await c.freeze();
+                else
+                    await c.unfreeze();
+                return { frozen: Boolean(b.frozen) };
+            case "read":
+                await group().markAsRead();
+                return { read: true, channel_url: c.url };
+            case "typing":
+                typing = true;
+                await group().startTyping();
+                await new Promise((r) => {
+                    const timer = setTimeout(done, Number(b.seconds) * 1000);
+                    function done() {
+                        clearTimeout(timer);
+                        signal?.removeEventListener("abort", done);
+                        r();
+                    }
+                    signal?.addEventListener("abort", done, { once: true });
+                    if (signal?.aborted)
+                        done();
+                });
+                await group().endTyping();
+                typing = false;
+                return { typing: false, channel_url: c.url };
+            case "watch": {
+                const [{ GroupChannelHandler }, { OpenChannelHandler }, { ConnectionHandler },] = await Promise.all([
+                    import("@sendbird/chat/groupChannel"),
+                    import("@sendbird/chat/openChannel"),
+                    import("@sendbird/chat"),
+                ]);
+                let count = 0;
+                let finish;
+                let reason = "duration";
+                let ended = false;
+                const send = (event, ch, payload) => {
+                    if (ended || count >= Number(b.max_events) || ch.url !== c.url)
+                        return;
+                    emit({ event, channel_url: ch.url, data: payload });
+                    if (++count >= Number(b.max_events))
+                        finish?.("event_limit");
+                };
+                const base = {
+                    onMessageReceived: (ch, m) => send("message_received", ch, message(m)),
+                    onMessageUpdated: (ch, m) => send("message_updated", ch, message(m)),
+                    onMessageDeleted: (ch, id) => send("message_deleted", ch, { message_id: id }),
+                };
+                handlerKey = "sendbird-cli-watch";
+                const connectionLost = () => {
+                    reason = "connection_lost";
+                    finish?.(reason);
+                };
+                sb.addConnectionHandler(handlerKey, new ConnectionHandler({
+                    onDisconnected: connectionLost,
+                    onConnectionLost: connectionLost,
+                    onReconnectFailed: connectionLost,
+                }));
+                if (c.isOpenChannel())
+                    sb.openChannel.addOpenChannelHandler(handlerKey, new OpenChannelHandler({
+                        ...base,
+                        onUserEntered: (ch, u) => send("user_entered", ch, user(u)),
+                        onUserExited: (ch, u) => send("user_exited", ch, user(u)),
+                    }));
+                else
+                    sb.groupChannel.addGroupChannelHandler(handlerKey, new GroupChannelHandler({
+                        ...base,
+                        onTypingStatusUpdated: (ch) => send("typing", ch, { users: ch.getTypingUsers().map(user) }),
+                        onUnreadMemberStatusUpdated: (ch) => send("read_receipt", ch, { updated: true }),
+                        onUndeliveredMemberStatusUpdated: (ch) => send("delivery_receipt", ch, { updated: true }),
+                        onUserJoined: (ch, u) => send("user_joined", ch, user(u)),
+                        onUserLeft: (ch, u) => send("user_left", ch, user(u)),
+                        onReactionUpdated: (ch, e) => send("reaction", ch, {
+                            message_id: e.messageId,
+                            key: e.key,
+                            user_id: e.userId,
+                            operation: e.operation,
+                        }),
+                    }));
+                emit({ event: "ready", channel: channel(c), user_id: job.actor });
+                await new Promise((resolve) => {
+                    const timer = setTimeout(() => finish?.("duration"), Number(b.seconds) * 1000);
+                    const abort = () => finish?.("interrupted");
+                    finish = (why) => {
+                        ended = true;
+                        reason = why;
+                        clearTimeout(timer);
+                        signal?.removeEventListener("abort", abort);
+                        resolve();
+                    };
+                    signal?.addEventListener("abort", abort, { once: true });
+                    if (signal?.aborted)
+                        abort();
+                    if (reason === "connection_lost")
+                        finish(reason);
+                    else if (count >= Number(b.max_events))
+                        finish("event_limit");
+                });
+                if (reason === "connection_lost")
+                    throw new CliError("E_NETWORK", "SDK watch lost its connection; events may have been missed", 7);
+                return { event: "complete", reason, events: count };
+            }
+            default:
+                throw new CliError("E_COMMAND", "Unsupported SDK operation", 2);
+        }
+    }
+    finally {
+        if (handlerKey) {
+            sb.removeConnectionHandler(handlerKey);
+            sb.groupChannel.removeGroupChannelHandler(handlerKey);
+            sb.openChannel.removeOpenChannelHandler(handlerKey);
+        }
+        if (typing && c?.isGroupChannel())
+            await Promise.race([c.endTyping().catch(() => { }), delay(1000)]);
+        if (entered && c?.isOpenChannel())
+            await Promise.race([c.exit().catch(() => { }), delay(1000)]);
+        await Promise.race([sb.disconnect().catch(() => { }), delay(1500)]);
+    }
+}
+//# sourceMappingURL=sdk-runtime.js.map