allowRfc2544BenchmarkRange: true,

};

const SLACK_DM_CHANNEL_CACHE_MAX = 1024;

const SLACK_DNS_RETRY_CODES = new Set(["EAI_AGAIN", "ENOTFOUND", "UND_ERR_DNS_RESOLVE_FAILED"]);

const SLACK_DNS_RETRY_ATTEMPTS = 2;

const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;

const slackDmChannelCache = new Map<string, string>();

const slackSendQueues = new Map<string, Promise<void>>();

return new Error(message);

}

function readSlackRequestErrorCode(value: unknown): string | undefined {

if (!value || typeof value !== "object") {

return undefined;

}

const code = (value as { code?: unknown }).code;

return typeof code === "string" ? code.toUpperCase() : undefined;

}

function readSlackRequestErrorMessage(value: unknown): string {

if (value instanceof Error) {

return value.message;

}

return typeof value === "string" ? value : "";

}

function hasSlackDnsRequestSignal(err: unknown): boolean {

let current: unknown = err;

const seen = new Set<unknown>();

for (let depth = 0; current && typeof current === "object" && depth < 6; depth += 1) {

if (seen.has(current)) {

return false;

}

seen.add(current);

const code = readSlackRequestErrorCode(current);

if (code && SLACK_DNS_RETRY_CODES.has(code)) {

return true;

}

const message = readSlackRequestErrorMessage(current);

if (/\b(EAI_AGAIN|ENOTFOUND|UND_ERR_DNS_RESOLVE_FAILED)\b/i.test(message)) {

return true;

}

current =

(current as { original?: unknown; cause?: unknown }).original ??

(current as { cause?: unknown }).cause;

}

return false;

}

function delaySlackDnsRetry(attempt: number): Promise<void> {

return new Promise((resolve) =>

setTimeout(resolve, SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt)),

);

}

async function withSlackDnsRequestRetry<T>(operation: string, fn: () => Promise<T>): Promise<T> {

for (let attempt = 0; ; attempt += 1) {

try {

return await fn();

} catch (err) {

if (attempt >= SLACK_DNS_RETRY_ATTEMPTS || !hasSlackDnsRequestSignal(err)) {

throw err;

}

logVerbose(

`slack send: retrying ${operation} after transient DNS request error (${attempt + 1}/${SLACK_DNS_RETRY_ATTEMPTS})`,

);

await delaySlackDnsRetry(attempt + 1);

}

}

}

function isSlackCustomizeScopeError(err: unknown): boolean {

const data = getSlackWebApiErrorData(err);

const code = normalizeLowercaseStringOrEmpty(normalizeSlackApiString(data?.error));

try {

// Slack Web API types model icon_url and icon_emoji as mutually exclusive.

// Build payloads in explicit branches so TS and runtime stay aligned.

if (params.identity?.iconUrl) {

return await postChatMessage({

...basePayload,

...(params.identity.username ? { username: params.identity.username } : {}),

icon_url: params.identity.iconUrl,

});

const identity = params.identity;

if (identity?.iconUrl) {

return await withSlackDnsRequestRetry("chat.postMessage", () =>

postChatMessage({

...basePayload,

...(identity.username ? { username: identity.username } : {}),

icon_url: identity.iconUrl,

}),

);

}

if (params.identity?.iconEmoji) {

return await postChatMessage({

...basePayload,

...(params.identity.username ? { username: params.identity.username } : {}),

icon_emoji: params.identity.iconEmoji,

});

if (identity?.iconEmoji) {

return await withSlackDnsRequestRetry("chat.postMessage", () =>

postChatMessage({

...basePayload,

...(identity.username ? { username: identity.username } : {}),

icon_emoji: identity.iconEmoji,

}),

);

}

return await postChatMessage({

...basePayload,

...(params.identity?.username ? { username: params.identity.username } : {}),

});

return await withSlackDnsRequestRetry("chat.postMessage", () =>

postChatMessage({

...basePayload,

...(identity?.username ? { username: identity.username } : {}),

}),

);

} catch (err) {

if (!hasCustomIdentity(params.identity) || !isSlackCustomizeScopeError(err)) {

throw err;

}

logVerbose("slack send: missing chat:write.customize, retrying without custom identity");

return postChatMessage(basePayload);

return withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(basePayload));

}

}

if (cachedChannelId) {

return { channelId: cachedChannelId, isDm: true, cacheHit: true };

}

const response = await client.conversations.open({ users: recipient.id });

const response = await withSlackDnsRequestRetry("conversations.open", () =>

client.conversations.open({ users: recipient.id }),

);

const channelId = response.channel?.id;

if (!channelId) {

throw new Error("Failed to open Slack DM channel");

// Use the 3-step upload flow (getUploadURLExternal -> POST -> completeUploadExternal)

// instead of files.uploadV2 which relies on the deprecated files.upload endpoint

// and can fail with missing_scope even when files:write is granted.

const uploadUrlResp = await params.client.files.getUploadURLExternal({

filename: uploadFileName,

length: buffer.length,

});

const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () =>

params.client.files.getUploadURLExternal({

filename: uploadFileName,

length: buffer.length,

}),

);

if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) {

throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);

}

const uploadFileId = uploadUrlResp.file_id;

// Upload the file content to the presigned URL

const uploadBody = new Uint8Array(buffer) as BodyInit;

}

// Complete the upload and share to channel/thread

const completeResp = await params.client.files.completeUploadExternal({

files: [{ id: uploadUrlResp.file_id, title: uploadTitle }],

channel_id: params.channelId,

...(params.caption ? { initial_comment: params.caption } : {}),

...(params.threadTs ? { thread_ts: params.threadTs } : {}),

});

const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () =>

params.client.files.completeUploadExternal({

files: [{ id: uploadFileId, title: uploadTitle }],

channel_id: params.channelId,

...(params.caption ? { initial_comment: params.caption } : {}),

...(params.threadTs ? { thread_ts: params.threadTs } : {}),

}),

);

if (!completeResp.ok) {

throw new Error(`Failed to complete upload: ${completeResp.error ?? "unknown error"}`);

}

return uploadUrlResp.file_id;

return uploadFileId;

}

export async function sendMessageSlack(