skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/sessions/level-overrides.d.ts

@@ -0,0 +1,10 @@
+import type { SessionEntry } from "../config/sessions.js";
+import { type VerboseLevel } from "../auto-reply/thinking.js";
+export declare function parseVerboseOverride(raw: unknown): {
+    ok: true;
+    value: VerboseLevel | null | undefined;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function applyVerboseOverride(entry: SessionEntry, level: VerboseLevel | null | undefined): void;

package/dist/plugin-sdk/sessions/model-overrides.d.ts

@@ -0,0 +1,14 @@
+import type { SessionEntry } from "../config/sessions.js";
+export type ModelOverrideSelection = {
+    provider: string;
+    model: string;
+    isDefault?: boolean;
+};
+export declare function applyModelOverrideToSessionEntry(params: {
+    entry: SessionEntry;
+    selection: ModelOverrideSelection;
+    profileOverride?: string;
+    profileOverrideSource?: "auto" | "user";
+}): {
+    updated: boolean;
+};

package/dist/plugin-sdk/sessions/send-policy.d.ts

@@ -0,0 +1,11 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { SessionChatType, SessionEntry } from "../config/sessions.js";
+export type SessionSendPolicyDecision = "allow" | "deny";
+export declare function normalizeSendPolicy(raw?: string | null): SessionSendPolicyDecision | undefined;
+export declare function resolveSendPolicy(params: {
+    cfg: SKYKOIConfig;
+    entry?: SessionEntry;
+    sessionKey?: string;
+    channel?: string;
+    chatType?: SessionChatType;
+}): SessionSendPolicyDecision;

package/dist/plugin-sdk/sessions/session-key-utils.d.ts

@@ -0,0 +1,8 @@
+export type ParsedAgentSessionKey = {
+    agentId: string;
+    rest: string;
+};
+export declare function parseAgentSessionKey(sessionKey: string | undefined | null): ParsedAgentSessionKey | null;
+export declare function isSubagentSessionKey(sessionKey: string | undefined | null): boolean;
+export declare function isAcpSessionKey(sessionKey: string | undefined | null): boolean;
+export declare function resolveThreadParentSessionKey(sessionKey: string | undefined | null): string | null;

package/dist/plugin-sdk/sessions/session-label.d.ts

@@ -0,0 +1,9 @@
+export declare const SESSION_LABEL_MAX_LENGTH = 64;
+export type ParsedSessionLabel = {
+    ok: true;
+    label: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseSessionLabel(raw: unknown): ParsedSessionLabel;

package/dist/plugin-sdk/sessions/transcript-events.d.ts

@@ -0,0 +1,7 @@
+type SessionTranscriptUpdate = {
+    sessionFile: string;
+};
+type SessionTranscriptListener = (update: SessionTranscriptUpdate) => void;
+export declare function onSessionTranscriptUpdate(listener: SessionTranscriptListener): () => void;
+export declare function emitSessionTranscriptUpdate(sessionFile: string): void;
+export {};

package/dist/plugin-sdk/shared/text/reasoning-tags.d.ts

@@ -0,0 +1,6 @@
+export type ReasoningTagMode = "strict" | "preserve";
+export type ReasoningTagTrim = "none" | "start" | "both";
+export declare function stripReasoningTagsFromText(text: string, options?: {
+    mode?: ReasoningTagMode;
+    trim?: ReasoningTagTrim;
+}): string;

package/dist/plugin-sdk/signal/accounts.d.ts

@@ -0,0 +1,17 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { SignalAccountConfig } from "../config/types.js";
+export type ResolvedSignalAccount = {
+    accountId: string;
+    enabled: boolean;
+    name?: string;
+    baseUrl: string;
+    configured: boolean;
+    config: SignalAccountConfig;
+};
+export declare function listSignalAccountIds(cfg: SKYKOIConfig): string[];
+export declare function resolveDefaultSignalAccountId(cfg: SKYKOIConfig): string;
+export declare function resolveSignalAccount(params: {
+    cfg: SKYKOIConfig;
+    accountId?: string | null;
+}): ResolvedSignalAccount;
+export declare function listEnabledSignalAccounts(cfg: SKYKOIConfig): ResolvedSignalAccount[];

package/dist/plugin-sdk/signal/client.d.ts

@@ -0,0 +1,32 @@
+export type SignalRpcOptions = {
+    baseUrl: string;
+    timeoutMs?: number;
+};
+export type SignalRpcError = {
+    code?: number;
+    message?: string;
+    data?: unknown;
+};
+export type SignalRpcResponse<T> = {
+    jsonrpc?: string;
+    result?: T;
+    error?: SignalRpcError;
+    id?: string | number | null;
+};
+export type SignalSseEvent = {
+    event?: string;
+    data?: string;
+    id?: string;
+};
+export declare function signalRpcRequest<T = unknown>(method: string, params: Record<string, unknown> | undefined, opts: SignalRpcOptions): Promise<T>;
+export declare function signalCheck(baseUrl: string, timeoutMs?: number): Promise<{
+    ok: boolean;
+    status?: number | null;
+    error?: string | null;
+}>;
+export declare function streamSignalEvents(params: {
+    baseUrl: string;
+    account?: string;
+    abortSignal?: AbortSignal;
+    onEvent: (event: SignalSseEvent) => void;
+}): Promise<void>;

package/dist/plugin-sdk/signal/daemon.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeEnv } from "../runtime.js";
+export type SignalDaemonOpts = {
+    cliPath: string;
+    account?: string;
+    httpHost: string;
+    httpPort: number;
+    receiveMode?: "on-start" | "manual";
+    ignoreAttachments?: boolean;
+    ignoreStories?: boolean;
+    sendReadReceipts?: boolean;
+    runtime?: RuntimeEnv;
+};
+export type SignalDaemonHandle = {
+    pid?: number;
+    stop: () => void;
+};
+export declare function classifySignalCliLogLine(line: string): "log" | "error" | null;
+export declare function spawnSignalDaemon(opts: SignalDaemonOpts): SignalDaemonHandle;

package/dist/plugin-sdk/signal/format.d.ts

@@ -0,0 +1,17 @@
+import type { MarkdownTableMode } from "../config/types.base.js";
+type SignalTextStyle = "BOLD" | "ITALIC" | "STRIKETHROUGH" | "MONOSPACE" | "SPOILER";
+export type SignalTextStyleRange = {
+    start: number;
+    length: number;
+    style: SignalTextStyle;
+};
+export type SignalFormattedText = {
+    text: string;
+    styles: SignalTextStyleRange[];
+};
+type SignalMarkdownOptions = {
+    tableMode?: MarkdownTableMode;
+};
+export declare function markdownToSignalText(markdown: string, options?: SignalMarkdownOptions): SignalFormattedText;
+export declare function markdownToSignalTextChunks(markdown: string, limit: number, options?: SignalMarkdownOptions): SignalFormattedText[];
+export {};

package/dist/plugin-sdk/signal/identity.d.ts

@@ -0,0 +1,23 @@
+export type SignalSender = {
+    kind: "phone";
+    raw: string;
+    e164: string;
+} | {
+    kind: "uuid";
+    raw: string;
+};
+export declare function resolveSignalSender(params: {
+    sourceNumber?: string | null;
+    sourceUuid?: string | null;
+}): SignalSender | null;
+export declare function formatSignalSenderId(sender: SignalSender): string;
+export declare function formatSignalSenderDisplay(sender: SignalSender): string;
+export declare function formatSignalPairingIdLine(sender: SignalSender): string;
+export declare function resolveSignalRecipient(sender: SignalSender): string;
+export declare function resolveSignalPeerId(sender: SignalSender): string;
+export declare function isSignalSenderAllowed(sender: SignalSender, allowFrom: string[]): boolean;
+export declare function isSignalGroupAllowed(params: {
+    groupPolicy: "open" | "disabled" | "allowlist";
+    allowFrom: string[];
+    sender: SignalSender;
+}): boolean;

package/dist/plugin-sdk/signal/index.d.ts

@@ -0,0 +1,5 @@
+export { monitorSignalProvider } from "./monitor.js";
+export { probeSignal } from "./probe.js";
+export { sendMessageSignal } from "./send.js";
+export { sendReactionSignal, removeReactionSignal } from "./send-reactions.js";
+export { resolveSignalReactionLevel } from "./reaction-level.js";

package/dist/plugin-sdk/signal/monitor/event-handler.d.ts

@@ -0,0 +1,5 @@
+import type { SignalEventHandlerDeps } from "./event-handler.types.js";
+export declare function createSignalEventHandler(deps: SignalEventHandlerDeps): (event: {
+    event?: string;
+    data?: string;
+}) => Promise<void>;

package/dist/plugin-sdk/signal/monitor/event-handler.types.d.ts

@@ -0,0 +1,117 @@
+import type { HistoryEntry } from "../../auto-reply/reply/history.js";
+import type { ReplyPayload } from "../../auto-reply/types.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { DmPolicy, GroupPolicy, SignalReactionNotificationMode } from "../../config/types.js";
+import type { RuntimeEnv } from "../../runtime.js";
+import type { SignalSender } from "../identity.js";
+export type SignalEnvelope = {
+    sourceNumber?: string | null;
+    sourceUuid?: string | null;
+    sourceName?: string | null;
+    timestamp?: number | null;
+    dataMessage?: SignalDataMessage | null;
+    editMessage?: {
+        dataMessage?: SignalDataMessage | null;
+    } | null;
+    syncMessage?: unknown;
+    reactionMessage?: SignalReactionMessage | null;
+};
+export type SignalDataMessage = {
+    timestamp?: number;
+    message?: string | null;
+    attachments?: Array<SignalAttachment>;
+    groupInfo?: {
+        groupId?: string | null;
+        groupName?: string | null;
+    } | null;
+    quote?: {
+        text?: string | null;
+    } | null;
+    reaction?: SignalReactionMessage | null;
+};
+export type SignalReactionMessage = {
+    emoji?: string | null;
+    targetAuthor?: string | null;
+    targetAuthorUuid?: string | null;
+    targetSentTimestamp?: number | null;
+    isRemove?: boolean | null;
+    groupInfo?: {
+        groupId?: string | null;
+        groupName?: string | null;
+    } | null;
+};
+export type SignalAttachment = {
+    id?: string | null;
+    contentType?: string | null;
+    filename?: string | null;
+    size?: number | null;
+};
+export type SignalReactionTarget = {
+    kind: "phone" | "uuid";
+    id: string;
+    display: string;
+};
+export type SignalReceivePayload = {
+    envelope?: SignalEnvelope | null;
+    exception?: {
+        message?: string;
+    } | null;
+};
+export type SignalEventHandlerDeps = {
+    runtime: RuntimeEnv;
+    cfg: SKYKOIConfig;
+    baseUrl: string;
+    account?: string;
+    accountId: string;
+    blockStreaming?: boolean;
+    historyLimit: number;
+    groupHistories: Map<string, HistoryEntry[]>;
+    textLimit: number;
+    dmPolicy: DmPolicy;
+    allowFrom: string[];
+    groupAllowFrom: string[];
+    groupPolicy: GroupPolicy;
+    reactionMode: SignalReactionNotificationMode;
+    reactionAllowlist: string[];
+    mediaMaxBytes: number;
+    ignoreAttachments: boolean;
+    sendReadReceipts: boolean;
+    readReceiptsViaDaemon: boolean;
+    fetchAttachment: (params: {
+        baseUrl: string;
+        account?: string;
+        attachment: SignalAttachment;
+        sender?: string;
+        groupId?: string;
+        maxBytes: number;
+    }) => Promise<{
+        path: string;
+        contentType?: string;
+    } | null>;
+    deliverReplies: (params: {
+        replies: ReplyPayload[];
+        target: string;
+        baseUrl: string;
+        account?: string;
+        accountId?: string;
+        runtime: RuntimeEnv;
+        maxBytes: number;
+        textLimit: number;
+    }) => Promise<void>;
+    resolveSignalReactionTargets: (reaction: SignalReactionMessage) => SignalReactionTarget[];
+    isSignalReactionMessage: (reaction: SignalReactionMessage | null | undefined) => reaction is SignalReactionMessage;
+    shouldEmitSignalReactionNotification: (params: {
+        mode?: SignalReactionNotificationMode;
+        account?: string | null;
+        targets?: SignalReactionTarget[];
+        sender?: SignalSender | null;
+        allowlist?: string[];
+    }) => boolean;
+    buildSignalReactionSystemEventText: (params: {
+        emojiLabel: string;
+        actorLabel: string;
+        messageId: string;
+        targetLabel?: string;
+        groupLabel?: string;
+    }) => string;
+};

package/dist/plugin-sdk/signal/monitor.d.ts

@@ -0,0 +1,23 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { RuntimeEnv } from "../runtime.js";
+export type MonitorSignalOpts = {
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    account?: string;
+    accountId?: string;
+    config?: SKYKOIConfig;
+    baseUrl?: string;
+    autoStart?: boolean;
+    startupTimeoutMs?: number;
+    cliPath?: string;
+    httpHost?: string;
+    httpPort?: number;
+    receiveMode?: "on-start" | "manual";
+    ignoreAttachments?: boolean;
+    ignoreStories?: boolean;
+    sendReadReceipts?: boolean;
+    allowFrom?: Array<string | number>;
+    groupAllowFrom?: Array<string | number>;
+    mediaMaxMb?: number;
+};
+export declare function monitorSignalProvider(opts?: MonitorSignalOpts): Promise<void>;

package/dist/plugin-sdk/signal/probe.d.ts

@@ -0,0 +1,8 @@
+export type SignalProbe = {
+    ok: boolean;
+    status?: number | null;
+    error?: string | null;
+    elapsedMs: number;
+    version?: string | null;
+};
+export declare function probeSignal(baseUrl: string, timeoutMs: number): Promise<SignalProbe>;

package/dist/plugin-sdk/signal/reaction-level.d.ts

@@ -0,0 +1,24 @@
+import type { SKYKOIConfig } from "../config/config.js";
+export type SignalReactionLevel = "off" | "ack" | "minimal" | "extensive";
+export type ResolvedSignalReactionLevel = {
+    level: SignalReactionLevel;
+    /** Whether ACK reactions (e.g., 👀 when processing) are enabled. */
+    ackEnabled: boolean;
+    /** Whether agent-controlled reactions are enabled. */
+    agentReactionsEnabled: boolean;
+    /** Guidance level for agent reactions (minimal = sparse, extensive = liberal). */
+    agentReactionGuidance?: "minimal" | "extensive";
+};
+/**
+ * Resolve the effective reaction level and its implications for Signal.
+ *
+ * Levels:
+ * - "off": No reactions at all
+ * - "ack": Only automatic ack reactions (👀 when processing), no agent reactions
+ * - "minimal": Agent can react, but sparingly (default)
+ * - "extensive": Agent can react liberally
+ */
+export declare function resolveSignalReactionLevel(params: {
+    cfg: SKYKOIConfig;
+    accountId?: string;
+}): ResolvedSignalReactionLevel;

package/dist/plugin-sdk/signal/send-reactions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Signal reactions via signal-cli JSON-RPC API
+ */
+export type SignalReactionOpts = {
+    baseUrl?: string;
+    account?: string;
+    accountId?: string;
+    timeoutMs?: number;
+    targetAuthor?: string;
+    targetAuthorUuid?: string;
+    groupId?: string;
+};
+export type SignalReactionResult = {
+    ok: boolean;
+    timestamp?: number;
+};
+/**
+ * Send a Signal reaction to a message
+ * @param recipient - UUID or E.164 phone number of the message author
+ * @param targetTimestamp - Message ID (timestamp) to react to
+ * @param emoji - Emoji to react with
+ * @param opts - Optional account/connection overrides
+ */
+export declare function sendReactionSignal(recipient: string, targetTimestamp: number, emoji: string, opts?: SignalReactionOpts): Promise<SignalReactionResult>;
+/**
+ * Remove a Signal reaction from a message
+ * @param recipient - UUID or E.164 phone number of the message author
+ * @param targetTimestamp - Message ID (timestamp) to remove reaction from
+ * @param emoji - Emoji to remove
+ * @param opts - Optional account/connection overrides
+ */
+export declare function removeReactionSignal(recipient: string, targetTimestamp: number, emoji: string, opts?: SignalReactionOpts): Promise<SignalReactionResult>;

package/dist/plugin-sdk/signal/send.d.ts

@@ -0,0 +1,24 @@
+import { type SignalTextStyleRange } from "./format.js";
+export type SignalSendOpts = {
+    baseUrl?: string;
+    account?: string;
+    accountId?: string;
+    mediaUrl?: string;
+    maxBytes?: number;
+    timeoutMs?: number;
+    textMode?: "markdown" | "plain";
+    textStyles?: SignalTextStyleRange[];
+};
+export type SignalSendResult = {
+    messageId: string;
+    timestamp?: number;
+};
+export type SignalRpcOpts = Pick<SignalSendOpts, "baseUrl" | "account" | "accountId" | "timeoutMs">;
+export type SignalReceiptType = "read" | "viewed";
+export declare function sendMessageSignal(to: string, text: string, opts?: SignalSendOpts): Promise<SignalSendResult>;
+export declare function sendTypingSignal(to: string, opts?: SignalRpcOpts & {
+    stop?: boolean;
+}): Promise<boolean>;
+export declare function sendReadReceiptSignal(to: string, targetTimestamp: number, opts?: SignalRpcOpts & {
+    type?: SignalReceiptType;
+}): Promise<boolean>;

package/dist/plugin-sdk/signal/sse-reconnect.d.ts

@@ -0,0 +1,13 @@
+import type { BackoffPolicy } from "../infra/backoff.js";
+import type { RuntimeEnv } from "../runtime.js";
+import { type SignalSseEvent } from "./client.js";
+type RunSignalSseLoopParams = {
+    baseUrl: string;
+    account?: string;
+    abortSignal?: AbortSignal;
+    runtime: RuntimeEnv;
+    onEvent: (event: SignalSseEvent) => void;
+    policy?: Partial<BackoffPolicy>;
+};
+export declare function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, policy, }: RunSignalSseLoopParams): Promise<void>;
+export {};

package/dist/plugin-sdk/slack/accounts.d.ts

@@ -0,0 +1,32 @@
+import type { SKYKOIConfig } 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;
+    botTokenSource: SlackTokenSource;
+    appTokenSource: 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 function listSlackAccountIds(cfg: SKYKOIConfig): string[];
+export declare function resolveDefaultSlackAccountId(cfg: SKYKOIConfig): string;
+export declare function resolveSlackAccount(params: {
+    cfg: SKYKOIConfig;
+    accountId?: string | null;
+}): ResolvedSlackAccount;
+export declare function listEnabledSlackAccounts(cfg: SKYKOIConfig): ResolvedSlackAccount[];
+export declare function resolveSlackReplyToMode(account: ResolvedSlackAccount, chatType?: string | null): "off" | "first" | "all";

package/dist/plugin-sdk/slack/actions.d.ts

@@ -0,0 +1,53 @@
+import type { WebClient } from "@slack/web-api";
+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[];
+    }>;
+};
+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;
+    threadTs?: string;
+}): Promise<import("./send.js").SlackSendResult>;
+export declare function editSlackMessage(channelId: string, messageId: string, content: string, opts?: SlackActionClientOpts): 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[]>;

package/dist/plugin-sdk/slack/channel-migration.d.ts

@@ -0,0 +1,20 @@
+import type { SKYKOIConfig } 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: SKYKOIConfig;
+    accountId?: string | null;
+    oldChannelId: string;
+    newChannelId: string;
+}): SlackChannelMigrationResult;
+export {};

package/dist/plugin-sdk/slack/client.d.ts

@@ -0,0 +1,4 @@
+import { type RetryOptions, type WebClientOptions, WebClient } from "@slack/web-api";
+export declare const SLACK_DEFAULT_RETRY_OPTIONS: RetryOptions;
+export declare function resolveSlackWebClientOptions(options?: WebClientOptions): WebClientOptions;
+export declare function createSlackWebClient(token: string, options?: WebClientOptions): WebClient;

package/dist/plugin-sdk/slack/directory-live.d.ts

@@ -0,0 +1,4 @@
+import type { DirectoryConfigParams } from "../channels/plugins/directory-config.js";
+import type { ChannelDirectoryEntry } from "../channels/plugins/types.js";
+export declare function listSlackDirectoryPeersLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+export declare function listSlackDirectoryGroupsLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;

package/dist/plugin-sdk/slack/format.d.ts

@@ -0,0 +1,7 @@
+import type { MarkdownTableMode } from "../config/types.base.js";
+type SlackMarkdownOptions = {
+    tableMode?: MarkdownTableMode;
+};
+export declare function markdownToSlackMrkdwn(markdown: string, options?: SlackMarkdownOptions): string;
+export declare function markdownToSlackMrkdwnChunks(markdown: string, limit: number, options?: SlackMarkdownOptions): string[];
+export {};

package/dist/plugin-sdk/slack/http/index.d.ts

@@ -0,0 +1 @@
+export * from "./registry.js";

package/dist/plugin-sdk/slack/http/registry.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type SlackHttpRequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void> | void;
+type RegisterSlackHttpHandlerArgs = {
+    path?: string | null;
+    handler: SlackHttpRequestHandler;
+    log?: (message: string) => void;
+    accountId?: string;
+};
+export declare function normalizeSlackWebhookPath(path?: string | null): string;
+export declare function registerSlackHttpHandler(params: RegisterSlackHttpHandlerArgs): () => void;
+export declare function handleSlackHttpRequest(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+export {};

package/dist/plugin-sdk/slack/index.d.ts

@@ -0,0 +1,6 @@
+export { listEnabledSlackAccounts, listSlackAccountIds, resolveDefaultSlackAccountId, resolveSlackAccount, } from "./accounts.js";
+export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, removeOwnSlackReactions, removeSlackReaction, sendSlackMessage, unpinSlackMessage, } from "./actions.js";
+export { monitorSlackProvider } from "./monitor.js";
+export { probeSlack } from "./probe.js";
+export { sendMessageSlack } from "./send.js";
+export { resolveSlackAppToken, resolveSlackBotToken } from "./token.js";

package/dist/plugin-sdk/slack/monitor/allow-list.d.ts

@@ -0,0 +1,20 @@
+import type { AllowlistMatch } from "../../channels/allowlist-match.js";
+export declare function normalizeSlackSlug(raw?: string): string;
+export declare function normalizeAllowList(list?: Array<string | number>): string[];
+export declare function normalizeAllowListLower(list?: Array<string | number>): string[];
+export type SlackAllowListMatch = AllowlistMatch<"wildcard" | "id" | "prefixed-id" | "prefixed-user" | "name" | "prefixed-name" | "slug">;
+export declare function resolveSlackAllowListMatch(params: {
+    allowList: string[];
+    id?: string;
+    name?: string;
+}): SlackAllowListMatch;
+export declare function allowListMatches(params: {
+    allowList: string[];
+    id?: string;
+    name?: string;
+}): boolean;
+export declare function resolveSlackUserAllowed(params: {
+    allowList?: Array<string | number>;
+    userId?: string;
+    userName?: string;
+}): boolean;

package/dist/plugin-sdk/slack/monitor/auth.d.ts

@@ -0,0 +1,10 @@
+import type { SlackMonitorContext } from "./context.js";
+export declare function resolveSlackEffectiveAllowFrom(ctx: SlackMonitorContext): Promise<{
+    allowFrom: string[];
+    allowFromLower: string[];
+}>;
+export declare function isSlackSenderAllowListed(params: {
+    allowListLower: string[];
+    senderId: string;
+    senderName?: string;
+}): boolean;