openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/slack/accounts.d.ts

@@ -1,35 +0,0 @@
-import type { OpenClawConfig } from "../config/config.js";
-import type { SlackAccountConfig } from "../config/types.js";
-export type SlackTokenSource = "env" | "config" | "none";
-export type ResolvedSlackAccount = {
-    accountId: string;
-    enabled: boolean;
-    name?: string;
-    botToken?: string;
-    appToken?: string;
-    userToken?: string;
-    botTokenSource: SlackTokenSource;
-    appTokenSource: SlackTokenSource;
-    userTokenSource: SlackTokenSource;
-    config: SlackAccountConfig;
-    groupPolicy?: SlackAccountConfig["groupPolicy"];
-    textChunkLimit?: SlackAccountConfig["textChunkLimit"];
-    mediaMaxMb?: SlackAccountConfig["mediaMaxMb"];
-    reactionNotifications?: SlackAccountConfig["reactionNotifications"];
-    reactionAllowlist?: SlackAccountConfig["reactionAllowlist"];
-    replyToMode?: SlackAccountConfig["replyToMode"];
-    replyToModeByChatType?: SlackAccountConfig["replyToModeByChatType"];
-    actions?: SlackAccountConfig["actions"];
-    slashCommand?: SlackAccountConfig["slashCommand"];
-    dm?: SlackAccountConfig["dm"];
-    channels?: SlackAccountConfig["channels"];
-};
-export declare const listSlackAccountIds: (cfg: OpenClawConfig) => string[];
-export declare const resolveDefaultSlackAccountId: (cfg: OpenClawConfig) => string;
-export declare function resolveSlackAccount(params: {
-    cfg: OpenClawConfig;
-    accountId?: string | null;
-}): ResolvedSlackAccount;
-export declare function listEnabledSlackAccounts(cfg: OpenClawConfig): ResolvedSlackAccount[];
-export declare function resolveSlackReplyToMode(account: ResolvedSlackAccount, chatType?: string | null): "off" | "first" | "all";
-//# sourceMappingURL=accounts.d.ts.map

package/dist/openclaw/src/slack/accounts.js

@@ -1,75 +0,0 @@
-import { normalizeChatType } from "../channels/chat-type.js";
-import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
-import { resolveAccountEntry } from "../routing/account-lookup.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
-import { resolveSlackAppToken, resolveSlackBotToken, resolveSlackUserToken } from "./token.js";
-const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("slack");
-export const listSlackAccountIds = listAccountIds;
-export const resolveDefaultSlackAccountId = resolveDefaultAccountId;
-function resolveAccountConfig(cfg, accountId) {
-    return resolveAccountEntry(cfg.channels?.slack?.accounts, accountId);
-}
-function mergeSlackAccountConfig(cfg, accountId) {
-    const { accounts: _ignored, ...base } = (cfg.channels?.slack ?? {});
-    const account = resolveAccountConfig(cfg, accountId) ?? {};
-    return { ...base, ...account };
-}
-export function resolveSlackAccount(params) {
-    const accountId = normalizeAccountId(params.accountId);
-    const baseEnabled = params.cfg.channels?.slack?.enabled !== false;
-    const merged = mergeSlackAccountConfig(params.cfg, accountId);
-    const accountEnabled = merged.enabled !== false;
-    const enabled = baseEnabled && accountEnabled;
-    const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-    const envBot = allowEnv ? resolveSlackBotToken(process.env.SLACK_BOT_TOKEN) : undefined;
-    const envApp = allowEnv ? resolveSlackAppToken(process.env.SLACK_APP_TOKEN) : undefined;
-    const envUser = allowEnv ? resolveSlackUserToken(process.env.SLACK_USER_TOKEN) : undefined;
-    const configBot = resolveSlackBotToken(merged.botToken, `channels.slack.accounts.${accountId}.botToken`);
-    const configApp = resolveSlackAppToken(merged.appToken, `channels.slack.accounts.${accountId}.appToken`);
-    const configUser = resolveSlackUserToken(merged.userToken, `channels.slack.accounts.${accountId}.userToken`);
-    const botToken = configBot ?? envBot;
-    const appToken = configApp ?? envApp;
-    const userToken = configUser ?? envUser;
-    const botTokenSource = configBot ? "config" : envBot ? "env" : "none";
-    const appTokenSource = configApp ? "config" : envApp ? "env" : "none";
-    const userTokenSource = configUser ? "config" : envUser ? "env" : "none";
-    return {
-        accountId,
-        enabled,
-        name: merged.name?.trim() || undefined,
-        botToken,
-        appToken,
-        userToken,
-        botTokenSource,
-        appTokenSource,
-        userTokenSource,
-        config: merged,
-        groupPolicy: merged.groupPolicy,
-        textChunkLimit: merged.textChunkLimit,
-        mediaMaxMb: merged.mediaMaxMb,
-        reactionNotifications: merged.reactionNotifications,
-        reactionAllowlist: merged.reactionAllowlist,
-        replyToMode: merged.replyToMode,
-        replyToModeByChatType: merged.replyToModeByChatType,
-        actions: merged.actions,
-        slashCommand: merged.slashCommand,
-        dm: merged.dm,
-        channels: merged.channels,
-    };
-}
-export function listEnabledSlackAccounts(cfg) {
-    return listSlackAccountIds(cfg)
-        .map((accountId) => resolveSlackAccount({ cfg, accountId }))
-        .filter((account) => account.enabled);
-}
-export function resolveSlackReplyToMode(account, chatType) {
-    const normalized = normalizeChatType(chatType ?? undefined);
-    if (normalized && account.replyToModeByChatType?.[normalized] !== undefined) {
-        return account.replyToModeByChatType[normalized] ?? "off";
-    }
-    if (normalized === "direct" && account.dm?.replyToMode !== undefined) {
-        return account.dm.replyToMode;
-    }
-    return account.replyToMode ?? "off";
-}
-//# sourceMappingURL=accounts.js.map

package/dist/openclaw/src/slack/actions.d.ts

@@ -1,75 +0,0 @@
-import type { Block, KnownBlock, WebClient } from "@slack/web-api";
-import type { SlackMediaResult } from "./monitor/media.js";
-export type SlackActionClientOpts = {
-    accountId?: string;
-    token?: string;
-    client?: WebClient;
-};
-export type SlackMessageSummary = {
-    ts?: string;
-    text?: string;
-    user?: string;
-    thread_ts?: string;
-    reply_count?: number;
-    reactions?: Array<{
-        name?: string;
-        count?: number;
-        users?: string[];
-    }>;
-    /** File attachments on this message. Present when the message has files. */
-    files?: Array<{
-        id?: string;
-        name?: string;
-        mimetype?: string;
-    }>;
-};
-export type SlackPin = {
-    type?: string;
-    message?: {
-        ts?: string;
-        text?: string;
-    };
-    file?: {
-        id?: string;
-        name?: string;
-    };
-};
-export declare function reactSlackMessage(channelId: string, messageId: string, emoji: string, opts?: SlackActionClientOpts): Promise<void>;
-export declare function removeSlackReaction(channelId: string, messageId: string, emoji: string, opts?: SlackActionClientOpts): Promise<void>;
-export declare function removeOwnSlackReactions(channelId: string, messageId: string, opts?: SlackActionClientOpts): Promise<string[]>;
-export declare function listSlackReactions(channelId: string, messageId: string, opts?: SlackActionClientOpts): Promise<SlackMessageSummary["reactions"]>;
-export declare function sendSlackMessage(to: string, content: string, opts?: SlackActionClientOpts & {
-    mediaUrl?: string;
-    mediaLocalRoots?: readonly string[];
-    threadTs?: string;
-    blocks?: (Block | KnownBlock)[];
-}): Promise<import("./send.js").SlackSendResult>;
-export declare function editSlackMessage(channelId: string, messageId: string, content: string, opts?: SlackActionClientOpts & {
-    blocks?: (Block | KnownBlock)[];
-}): Promise<void>;
-export declare function deleteSlackMessage(channelId: string, messageId: string, opts?: SlackActionClientOpts): Promise<void>;
-export declare function readSlackMessages(channelId: string, opts?: SlackActionClientOpts & {
-    limit?: number;
-    before?: string;
-    after?: string;
-    threadId?: string;
-}): Promise<{
-    messages: SlackMessageSummary[];
-    hasMore: boolean;
-}>;
-export declare function getSlackMemberInfo(userId: string, opts?: SlackActionClientOpts): Promise<import("@slack/web-api").UsersInfoResponse>;
-export declare function listSlackEmojis(opts?: SlackActionClientOpts): Promise<import("@slack/web-api").EmojiListResponse>;
-export declare function pinSlackMessage(channelId: string, messageId: string, opts?: SlackActionClientOpts): Promise<void>;
-export declare function unpinSlackMessage(channelId: string, messageId: string, opts?: SlackActionClientOpts): Promise<void>;
-export declare function listSlackPins(channelId: string, opts?: SlackActionClientOpts): Promise<SlackPin[]>;
-/**
- * Downloads a Slack file by ID and saves it to the local media store.
- * Fetches a fresh download URL via files.info to avoid using stale private URLs.
- * Returns null when the file cannot be found or downloaded.
- */
-export declare function downloadSlackFile(fileId: string, opts: SlackActionClientOpts & {
-    maxBytes: number;
-    channelId?: string;
-    threadId?: string;
-}): Promise<SlackMediaResult | null>;
-//# sourceMappingURL=actions.d.ts.map

package/dist/openclaw/src/slack/actions.js

@@ -1,285 +0,0 @@
-import { loadConfig } from "../config/config.js";
-import { logVerbose } from "../globals.js";
-import { resolveSlackAccount } from "./accounts.js";
-import { buildSlackBlocksFallbackText } from "./blocks-fallback.js";
-import { validateSlackBlocksArray } from "./blocks-input.js";
-import { createSlackWebClient } from "./client.js";
-import { resolveSlackMedia } from "./monitor/media.js";
-import { sendMessageSlack } from "./send.js";
-import { resolveSlackBotToken } from "./token.js";
-function resolveToken(explicit, accountId) {
-    const cfg = loadConfig();
-    const account = resolveSlackAccount({ cfg, accountId });
-    const token = resolveSlackBotToken(explicit ?? account.botToken ?? undefined);
-    if (!token) {
-        logVerbose(`slack actions: missing bot token for account=${account.accountId} explicit=${Boolean(explicit)} source=${account.botTokenSource ?? "unknown"}`);
-        throw new Error("SLACK_BOT_TOKEN or channels.slack.botToken is required for Slack actions");
-    }
-    return token;
-}
-function normalizeEmoji(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        throw new Error("Emoji is required for Slack reactions");
-    }
-    return trimmed.replace(/^:+|:+$/g, "");
-}
-async function getClient(opts = {}) {
-    const token = resolveToken(opts.token, opts.accountId);
-    return opts.client ?? createSlackWebClient(token);
-}
-async function resolveBotUserId(client) {
-    const auth = await client.auth.test();
-    if (!auth?.user_id) {
-        throw new Error("Failed to resolve Slack bot user id");
-    }
-    return auth.user_id;
-}
-export async function reactSlackMessage(channelId, messageId, emoji, opts = {}) {
-    const client = await getClient(opts);
-    await client.reactions.add({
-        channel: channelId,
-        timestamp: messageId,
-        name: normalizeEmoji(emoji),
-    });
-}
-export async function removeSlackReaction(channelId, messageId, emoji, opts = {}) {
-    const client = await getClient(opts);
-    await client.reactions.remove({
-        channel: channelId,
-        timestamp: messageId,
-        name: normalizeEmoji(emoji),
-    });
-}
-export async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
-    const client = await getClient(opts);
-    const userId = await resolveBotUserId(client);
-    const reactions = await listSlackReactions(channelId, messageId, { client });
-    const toRemove = new Set();
-    for (const reaction of reactions ?? []) {
-        const name = reaction?.name;
-        if (!name) {
-            continue;
-        }
-        const users = reaction?.users ?? [];
-        if (users.includes(userId)) {
-            toRemove.add(name);
-        }
-    }
-    if (toRemove.size === 0) {
-        return [];
-    }
-    await Promise.all(Array.from(toRemove, (name) => client.reactions.remove({
-        channel: channelId,
-        timestamp: messageId,
-        name,
-    })));
-    return Array.from(toRemove);
-}
-export async function listSlackReactions(channelId, messageId, opts = {}) {
-    const client = await getClient(opts);
-    const result = await client.reactions.get({
-        channel: channelId,
-        timestamp: messageId,
-        full: true,
-    });
-    const message = result.message;
-    return message?.reactions ?? [];
-}
-export async function sendSlackMessage(to, content, opts = {}) {
-    return await sendMessageSlack(to, content, {
-        accountId: opts.accountId,
-        token: opts.token,
-        mediaUrl: opts.mediaUrl,
-        mediaLocalRoots: opts.mediaLocalRoots,
-        client: opts.client,
-        threadTs: opts.threadTs,
-        blocks: opts.blocks,
-    });
-}
-export async function editSlackMessage(channelId, messageId, content, opts = {}) {
-    const client = await getClient(opts);
-    const blocks = opts.blocks == null ? undefined : validateSlackBlocksArray(opts.blocks);
-    const trimmedContent = content.trim();
-    await client.chat.update({
-        channel: channelId,
-        ts: messageId,
-        text: trimmedContent || (blocks ? buildSlackBlocksFallbackText(blocks) : " "),
-        ...(blocks ? { blocks } : {}),
-    });
-}
-export async function deleteSlackMessage(channelId, messageId, opts = {}) {
-    const client = await getClient(opts);
-    await client.chat.delete({
-        channel: channelId,
-        ts: messageId,
-    });
-}
-export async function readSlackMessages(channelId, opts = {}) {
-    const client = await getClient(opts);
-    // Use conversations.replies for thread messages, conversations.history for channel messages.
-    if (opts.threadId) {
-        const result = await client.conversations.replies({
-            channel: channelId,
-            ts: opts.threadId,
-            limit: opts.limit,
-            latest: opts.before,
-            oldest: opts.after,
-        });
-        return {
-            // conversations.replies includes the parent message; drop it for replies-only reads.
-            messages: (result.messages ?? []).filter((message) => message?.ts !== opts.threadId),
-            hasMore: Boolean(result.has_more),
-        };
-    }
-    const result = await client.conversations.history({
-        channel: channelId,
-        limit: opts.limit,
-        latest: opts.before,
-        oldest: opts.after,
-    });
-    return {
-        messages: (result.messages ?? []),
-        hasMore: Boolean(result.has_more),
-    };
-}
-export async function getSlackMemberInfo(userId, opts = {}) {
-    const client = await getClient(opts);
-    return await client.users.info({ user: userId });
-}
-export async function listSlackEmojis(opts = {}) {
-    const client = await getClient(opts);
-    return await client.emoji.list();
-}
-export async function pinSlackMessage(channelId, messageId, opts = {}) {
-    const client = await getClient(opts);
-    await client.pins.add({ channel: channelId, timestamp: messageId });
-}
-export async function unpinSlackMessage(channelId, messageId, opts = {}) {
-    const client = await getClient(opts);
-    await client.pins.remove({ channel: channelId, timestamp: messageId });
-}
-export async function listSlackPins(channelId, opts = {}) {
-    const client = await getClient(opts);
-    const result = await client.pins.list({ channel: channelId });
-    return (result.items ?? []);
-}
-function normalizeSlackScopeValue(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : undefined;
-}
-function collectSlackDirectShareChannelIds(file) {
-    const ids = new Set();
-    for (const group of [file.channels, file.groups, file.ims]) {
-        if (!Array.isArray(group)) {
-            continue;
-        }
-        for (const entry of group) {
-            if (typeof entry !== "string") {
-                continue;
-            }
-            const normalized = normalizeSlackScopeValue(entry);
-            if (normalized) {
-                ids.add(normalized);
-            }
-        }
-    }
-    return ids;
-}
-function collectSlackShareMaps(file) {
-    if (!file.shares || typeof file.shares !== "object" || Array.isArray(file.shares)) {
-        return [];
-    }
-    const shares = file.shares;
-    return [shares.public, shares.private].filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
-}
-function collectSlackSharedChannelIds(file) {
-    const ids = new Set();
-    for (const shareMap of collectSlackShareMaps(file)) {
-        for (const channelId of Object.keys(shareMap)) {
-            const normalized = normalizeSlackScopeValue(channelId);
-            if (normalized) {
-                ids.add(normalized);
-            }
-        }
-    }
-    return ids;
-}
-function collectSlackThreadShares(file, channelId) {
-    const matches = [];
-    for (const shareMap of collectSlackShareMaps(file)) {
-        const rawEntries = shareMap[channelId];
-        if (!Array.isArray(rawEntries)) {
-            continue;
-        }
-        for (const rawEntry of rawEntries) {
-            if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-                continue;
-            }
-            const entry = rawEntry;
-            const ts = typeof entry.ts === "string" ? normalizeSlackScopeValue(entry.ts) : undefined;
-            const threadTs = typeof entry.thread_ts === "string" ? normalizeSlackScopeValue(entry.thread_ts) : undefined;
-            matches.push({ channelId, ts, threadTs });
-        }
-    }
-    return matches;
-}
-function hasSlackScopeMismatch(params) {
-    const channelId = normalizeSlackScopeValue(params.channelId);
-    if (!channelId) {
-        return false;
-    }
-    const threadId = normalizeSlackScopeValue(params.threadId);
-    const directIds = collectSlackDirectShareChannelIds(params.file);
-    const sharedIds = collectSlackSharedChannelIds(params.file);
-    const hasChannelEvidence = directIds.size > 0 || sharedIds.size > 0;
-    const inChannel = directIds.has(channelId) || sharedIds.has(channelId);
-    if (hasChannelEvidence && !inChannel) {
-        return true;
-    }
-    if (!threadId) {
-        return false;
-    }
-    const threadShares = collectSlackThreadShares(params.file, channelId);
-    if (threadShares.length === 0) {
-        return false;
-    }
-    const threadEvidence = threadShares.filter((entry) => entry.threadTs || entry.ts);
-    if (threadEvidence.length === 0) {
-        return false;
-    }
-    return !threadEvidence.some((entry) => entry.threadTs === threadId || entry.ts === threadId);
-}
-/**
- * Downloads a Slack file by ID and saves it to the local media store.
- * Fetches a fresh download URL via files.info to avoid using stale private URLs.
- * Returns null when the file cannot be found or downloaded.
- */
-export async function downloadSlackFile(fileId, opts) {
-    const token = resolveToken(opts.token, opts.accountId);
-    const client = await getClient(opts);
-    // Fetch fresh file metadata (includes a current url_private_download).
-    const info = await client.files.info({ file: fileId });
-    const file = info.file;
-    if (!file?.url_private_download && !file?.url_private) {
-        return null;
-    }
-    if (hasSlackScopeMismatch({ file, channelId: opts.channelId, threadId: opts.threadId })) {
-        return null;
-    }
-    const results = await resolveSlackMedia({
-        files: [
-            {
-                id: file.id,
-                name: file.name,
-                mimetype: file.mimetype,
-                url_private: file.url_private,
-                url_private_download: file.url_private_download,
-            },
-        ],
-        token,
-        maxBytes: opts.maxBytes,
-    });
-    return results?.[0] ?? null;
-}
-//# sourceMappingURL=actions.js.map

package/dist/openclaw/src/slack/blocks-fallback.d.ts

@@ -1,3 +0,0 @@
-import type { Block, KnownBlock } from "@slack/web-api";
-export declare function buildSlackBlocksFallbackText(blocks: (Block | KnownBlock)[]): string;
-//# sourceMappingURL=blocks-fallback.d.ts.map

package/dist/openclaw/src/slack/blocks-fallback.js

@@ -1,77 +0,0 @@
-function cleanCandidate(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const normalized = value.replace(/\s+/g, " ").trim();
-    return normalized.length > 0 ? normalized : undefined;
-}
-function readSectionText(block) {
-    return cleanCandidate(block.text?.text);
-}
-function readHeaderText(block) {
-    return cleanCandidate(block.text?.text);
-}
-function readImageText(block) {
-    return cleanCandidate(block.alt_text) ?? cleanCandidate(block.title?.text);
-}
-function readVideoText(block) {
-    return cleanCandidate(block.title?.text) ?? cleanCandidate(block.alt_text);
-}
-function readContextText(block) {
-    if (!Array.isArray(block.elements)) {
-        return undefined;
-    }
-    const textParts = block.elements
-        .map((element) => cleanCandidate(element.text))
-        .filter((value) => Boolean(value));
-    return textParts.length > 0 ? textParts.join(" ") : undefined;
-}
-export function buildSlackBlocksFallbackText(blocks) {
-    for (const raw of blocks) {
-        const block = raw;
-        switch (block.type) {
-            case "header": {
-                const text = readHeaderText(block);
-                if (text) {
-                    return text;
-                }
-                break;
-            }
-            case "section": {
-                const text = readSectionText(block);
-                if (text) {
-                    return text;
-                }
-                break;
-            }
-            case "image": {
-                const text = readImageText(block);
-                if (text) {
-                    return text;
-                }
-                return "Shared an image";
-            }
-            case "video": {
-                const text = readVideoText(block);
-                if (text) {
-                    return text;
-                }
-                return "Shared a video";
-            }
-            case "file": {
-                return "Shared a file";
-            }
-            case "context": {
-                const text = readContextText(block);
-                if (text) {
-                    return text;
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return "Shared a Block Kit message";
-}
-//# sourceMappingURL=blocks-fallback.js.map

package/dist/openclaw/src/slack/blocks-input.d.ts

@@ -1,4 +0,0 @@
-import type { Block, KnownBlock } from "@slack/web-api";
-export declare function validateSlackBlocksArray(raw: unknown): (Block | KnownBlock)[];
-export declare function parseSlackBlocksInput(raw: unknown): (Block | KnownBlock)[] | undefined;
-//# sourceMappingURL=blocks-input.d.ts.map

package/dist/openclaw/src/slack/blocks-input.js

@@ -1,41 +0,0 @@
-const SLACK_MAX_BLOCKS = 50;
-function parseBlocksJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new Error("blocks must be valid JSON");
-    }
-}
-function assertBlocksArray(raw) {
-    if (!Array.isArray(raw)) {
-        throw new Error("blocks must be an array");
-    }
-    if (raw.length === 0) {
-        throw new Error("blocks must contain at least one block");
-    }
-    if (raw.length > SLACK_MAX_BLOCKS) {
-        throw new Error(`blocks cannot exceed ${SLACK_MAX_BLOCKS} items`);
-    }
-    for (const block of raw) {
-        if (!block || typeof block !== "object" || Array.isArray(block)) {
-            throw new Error("each block must be an object");
-        }
-        const type = block.type;
-        if (typeof type !== "string" || type.trim().length === 0) {
-            throw new Error("each block must include a non-empty string type");
-        }
-    }
-}
-export function validateSlackBlocksArray(raw) {
-    assertBlocksArray(raw);
-    return raw;
-}
-export function parseSlackBlocksInput(raw) {
-    if (raw == null) {
-        return undefined;
-    }
-    const parsed = typeof raw === "string" ? parseBlocksJson(raw) : raw;
-    return validateSlackBlocksArray(parsed);
-}
-//# sourceMappingURL=blocks-input.js.map

package/dist/openclaw/src/slack/channel-migration.d.ts

@@ -1,21 +0,0 @@
-import type { OpenClawConfig } from "../config/config.js";
-import type { SlackChannelConfig } from "../config/types.slack.js";
-type SlackChannels = Record<string, SlackChannelConfig>;
-type MigrationScope = "account" | "global";
-export type SlackChannelMigrationResult = {
-    migrated: boolean;
-    skippedExisting: boolean;
-    scopes: MigrationScope[];
-};
-export declare function migrateSlackChannelsInPlace(channels: SlackChannels | undefined, oldChannelId: string, newChannelId: string): {
-    migrated: boolean;
-    skippedExisting: boolean;
-};
-export declare function migrateSlackChannelConfig(params: {
-    cfg: OpenClawConfig;
-    accountId?: string | null;
-    oldChannelId: string;
-    newChannelId: string;
-}): SlackChannelMigrationResult;
-export {};
-//# sourceMappingURL=channel-migration.d.ts.map

package/dist/openclaw/src/slack/channel-migration.js

@@ -1,63 +0,0 @@
-import { normalizeAccountId } from "../routing/session-key.js";
-function resolveAccountChannels(cfg, accountId) {
-    if (!accountId) {
-        return {};
-    }
-    const normalized = normalizeAccountId(accountId);
-    const accounts = cfg.channels?.slack?.accounts;
-    if (!accounts || typeof accounts !== "object") {
-        return {};
-    }
-    const exact = accounts[normalized];
-    if (exact?.channels) {
-        return { channels: exact.channels };
-    }
-    const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalized.toLowerCase());
-    return { channels: matchKey ? accounts[matchKey]?.channels : undefined };
-}
-export function migrateSlackChannelsInPlace(channels, oldChannelId, newChannelId) {
-    if (!channels) {
-        return { migrated: false, skippedExisting: false };
-    }
-    if (oldChannelId === newChannelId) {
-        return { migrated: false, skippedExisting: false };
-    }
-    if (!Object.hasOwn(channels, oldChannelId)) {
-        return { migrated: false, skippedExisting: false };
-    }
-    if (Object.hasOwn(channels, newChannelId)) {
-        return { migrated: false, skippedExisting: true };
-    }
-    channels[newChannelId] = channels[oldChannelId];
-    delete channels[oldChannelId];
-    return { migrated: true, skippedExisting: false };
-}
-export function migrateSlackChannelConfig(params) {
-    const scopes = [];
-    let migrated = false;
-    let skippedExisting = false;
-    const accountChannels = resolveAccountChannels(params.cfg, params.accountId).channels;
-    if (accountChannels) {
-        const result = migrateSlackChannelsInPlace(accountChannels, params.oldChannelId, params.newChannelId);
-        if (result.migrated) {
-            migrated = true;
-            scopes.push("account");
-        }
-        if (result.skippedExisting) {
-            skippedExisting = true;
-        }
-    }
-    const globalChannels = params.cfg.channels?.slack?.channels;
-    if (globalChannels) {
-        const result = migrateSlackChannelsInPlace(globalChannels, params.oldChannelId, params.newChannelId);
-        if (result.migrated) {
-            migrated = true;
-            scopes.push("global");
-        }
-        if (result.skippedExisting) {
-            skippedExisting = true;
-        }
-    }
-    return { migrated, skippedExisting, scopes };
-}
-//# sourceMappingURL=channel-migration.js.map