botinabox 1.8.1 → 1.8.3

package/dist/channels/discord/adapter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DiscordAdapter — ChannelAdapter implementation for Discord.
+ * Story 4.6
+ */
+import type { ChannelAdapter, ChannelCapabilities, ChannelMeta, ChannelConfig, InboundMessage, OutboundPayload, SendResult, HealthStatus } from "../../shared/index.js";
+/** Minimal Discord client interface for mockability. */
+export interface DiscordClient {
+    sendMessage(channelId: string, content: string): Promise<{
+        id: string;
+    }>;
+}
+export declare class DiscordAdapter implements ChannelAdapter {
+    readonly id = "discord";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private client;
+    constructor(client?: DiscordClient);
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    receive(event: Record<string, unknown>): Promise<void>;
+}
+/** Factory function — default export for auto-discovery. */
+export default function createDiscordAdapter(client?: DiscordClient): DiscordAdapter;

package/dist/channels/discord/adapter.js

@@ -0,0 +1,70 @@
+/**
+ * DiscordAdapter — ChannelAdapter implementation for Discord.
+ * Story 4.6
+ */
+import { formatForDiscord } from "./outbound.js";
+export class DiscordAdapter {
+    id = "discord";
+    meta = {
+        displayName: "Discord",
+        icon: "https://discord.com/favicon.ico",
+        homepage: "https://discord.com",
+    };
+    capabilities = {
+        chatTypes: ["direct", "group", "channel"],
+        threads: true,
+        reactions: true,
+        editing: true,
+        media: true,
+        polls: false,
+        maxTextLength: 2000,
+        formattingMode: "markdown",
+    };
+    onMessage;
+    connected = false;
+    config = null;
+    client;
+    constructor(client) {
+        this.client = client ?? null;
+    }
+    async connect(config) {
+        this.config = config;
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.config = null;
+    }
+    async healthCheck() {
+        return { ok: this.connected };
+    }
+    async send(target, payload) {
+        if (!this.connected) {
+            return { success: false, error: "Not connected" };
+        }
+        const text = formatForDiscord(payload.text);
+        if (this.client) {
+            try {
+                const result = await this.client.sendMessage(target.peerId, text);
+                return { success: true, messageId: result.id };
+            }
+            catch (err) {
+                return { success: false, error: String(err) };
+            }
+        }
+        // No-op when no client provided
+        return { success: true };
+    }
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    async receive(event) {
+        if (this.onMessage) {
+            const { parseDiscordEvent } = await import("./inbound.js");
+            const msg = parseDiscordEvent(event);
+            await this.onMessage(msg);
+        }
+    }
+}
+/** Factory function — default export for auto-discovery. */
+export default function createDiscordAdapter(client) {
+    return new DiscordAdapter(client);
+}

package/dist/channels/discord/inbound.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Discord inbound message parsing.
+ * Story 4.6
+ */
+import type { InboundMessage } from "../../shared/index.js";
+export interface DiscordEvent {
+    id?: string;
+    channel_id?: string;
+    guild_id?: string;
+    author?: {
+        id?: string;
+        username?: string;
+    };
+    content?: string;
+    message_reference?: {
+        message_id?: string;
+        channel_id?: string;
+    };
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/**
+ * Parse a Discord message event into an InboundMessage.
+ */
+export declare function parseDiscordEvent(event: DiscordEvent): InboundMessage;

package/dist/channels/discord/inbound.js

@@ -0,0 +1,24 @@
+/**
+ * Discord inbound message parsing.
+ * Story 4.6
+ */
+/**
+ * Parse a Discord message event into an InboundMessage.
+ */
+export function parseDiscordEvent(event) {
+    const id = event.id ?? `discord-${Date.now()}`;
+    const channel = event.channel_id ?? "unknown";
+    const from = event.author?.id ?? "unknown";
+    const body = event.content ?? "";
+    const replyToId = event.message_reference?.message_id;
+    const receivedAt = event.timestamp ?? new Date().toISOString();
+    return {
+        id,
+        channel,
+        from,
+        body,
+        replyToId,
+        receivedAt,
+        raw: event,
+    };
+}

package/dist/channels/discord/models.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Discord channel configuration types.
+ * Story 4.6
+ */
+export interface DiscordConfig {
+    token: string;
+    guildId?: string;
+}

package/dist/channels/discord/models.js

@@ -0,0 +1,5 @@
+/**
+ * Discord channel configuration types.
+ * Story 4.6
+ */
+export {};

package/dist/channels/discord/outbound.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Discord outbound formatting.
+ * Discord uses native markdown — just enforce the 2000-char limit.
+ * Story 4.6
+ */
+/**
+ * Split text into Discord-compatible chunks (2000 char max each).
+ */
+export declare function chunkForDiscord(text: string): string[];
+/**
+ * Discord uses native markdown — no conversion needed.
+ * Returns the text unchanged (Discord renders it natively).
+ */
+export declare function formatForDiscord(text: string): string;

package/dist/channels/discord/outbound.js

@@ -0,0 +1,38 @@
+/**
+ * Discord outbound formatting.
+ * Discord uses native markdown — just enforce the 2000-char limit.
+ * Story 4.6
+ */
+const DISCORD_MAX_LENGTH = 2000;
+/**
+ * Split text into Discord-compatible chunks (2000 char max each).
+ */
+export function chunkForDiscord(text) {
+    if (text.length <= DISCORD_MAX_LENGTH)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > DISCORD_MAX_LENGTH) {
+        // Try to split at a word boundary
+        const slice = remaining.slice(0, DISCORD_MAX_LENGTH);
+        const lastSpace = slice.lastIndexOf(" ");
+        if (lastSpace > 0) {
+            chunks.push(remaining.slice(0, lastSpace));
+            remaining = remaining.slice(lastSpace + 1);
+        }
+        else {
+            chunks.push(remaining.slice(0, DISCORD_MAX_LENGTH));
+            remaining = remaining.slice(DISCORD_MAX_LENGTH);
+        }
+    }
+    if (remaining.length > 0)
+        chunks.push(remaining);
+    return chunks;
+}
+/**
+ * Discord uses native markdown — no conversion needed.
+ * Returns the text unchanged (Discord renders it natively).
+ */
+export function formatForDiscord(text) {
+    return text;
+}

package/dist/channels/slack/adapter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SlackAdapter — ChannelAdapter implementation for Slack.
+ * Story 4.5
+ */
+import type { ChannelAdapter, ChannelCapabilities, ChannelMeta, ChannelConfig, InboundMessage, OutboundPayload, SendResult, HealthStatus } from "../../shared/index.js";
+/** Minimal Bolt-compatible client interface for mockability. */
+export interface BoltClient {
+    postMessage(channel: string, text: string, threadTs?: string): Promise<{
+        ok: boolean;
+        ts?: string;
+    }>;
+}
+export declare class SlackAdapter implements ChannelAdapter {
+    readonly id = "slack";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private client;
+    constructor(client?: BoltClient);
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    receive(event: Record<string, unknown>): Promise<void>;
+}
+/** Factory function — default export for auto-discovery. */
+export default function createSlackAdapter(client?: BoltClient): SlackAdapter;

package/dist/channels/slack/adapter.js

@@ -0,0 +1,74 @@
+/**
+ * SlackAdapter — ChannelAdapter implementation for Slack.
+ * Story 4.5
+ */
+import { formatForSlack } from "./outbound.js";
+export class SlackAdapter {
+    id = "slack";
+    meta = {
+        displayName: "Slack",
+        icon: "https://slack.com/favicon.ico",
+        homepage: "https://slack.com",
+    };
+    capabilities = {
+        chatTypes: ["direct", "group", "channel"],
+        threads: true,
+        reactions: true,
+        editing: true,
+        media: true,
+        polls: false,
+        maxTextLength: 40_000,
+        formattingMode: "mrkdwn",
+    };
+    onMessage;
+    connected = false;
+    config = null;
+    client;
+    constructor(client) {
+        this.client = client ?? null;
+    }
+    async connect(config) {
+        this.config = config;
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.config = null;
+    }
+    async healthCheck() {
+        return { ok: this.connected };
+    }
+    async send(target, payload) {
+        if (!this.connected) {
+            return { success: false, error: "Not connected" };
+        }
+        const text = formatForSlack(payload.text);
+        if (this.client) {
+            try {
+                const result = await this.client.postMessage(target.peerId, text, target.threadId);
+                return { success: result.ok, messageId: result.ts };
+            }
+            catch (err) {
+                return { success: false, error: String(err) };
+            }
+        }
+        // No-op when no client provided
+        return { success: true };
+    }
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    async receive(event) {
+        if (this.onMessage) {
+            const { parseSlackEvent } = await import("./inbound.js");
+            const { enrichVoiceMessage } = await import("./inbound.js");
+            let msg = parseSlackEvent(event);
+            if (msg.body.includes("[Voice message") && this.config?.botToken) {
+                msg = await enrichVoiceMessage(msg, this.config.botToken);
+            }
+            await this.onMessage(msg);
+        }
+    }
+}
+/** Factory function — default export for auto-discovery. */
+export default function createSlackAdapter(client) {
+    return new SlackAdapter(client);
+}

package/dist/channels/slack/inbound.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Slack inbound message parsing.
+ * Story 4.5
+ */
+import type { InboundMessage } from "../../shared/index.js";
+export interface SlackFile {
+    id?: string;
+    filetype?: string;
+    subtype?: string;
+    url_private?: string;
+    preview?: string;
+    transcription?: {
+        status?: string;
+        preview?: {
+            content?: string;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface SlackEvent {
+    type: string;
+    subtype?: string;
+    client_msg_id?: string;
+    ts?: string;
+    event_ts?: string;
+    channel?: string;
+    user?: string;
+    text?: string;
+    thread_ts?: string;
+    files?: SlackFile[];
+    [key: string]: unknown;
+}
+/**
+ * Extract the text content from a voice message file.
+ * Prefers the transcription preview; falls back to the file preview text.
+ * Returns null if the file is not a voice message or has no transcript.
+ */
+export declare function extractVoiceTranscript(file: SlackFile): string | null;
+/**
+ * Parse a Slack event into an InboundMessage.
+ *
+ * Handles standard text messages and voice messages (file_share subtype
+ * with audio files). Voice message transcripts are extracted and prefixed
+ * with `[Voice message]`.
+ */
+export declare function parseSlackEvent(event: SlackEvent): InboundMessage;
+/**
+ * Enrich a voice message with local transcription when Slack's built-in
+ * transcription is unavailable.
+ *
+ * Downloads the audio file from Slack using the bot token, converts to WAV,
+ * and transcribes locally via whisper-node. Returns the original message
+ * unchanged if transcription fails or is not needed.
+ *
+ * @param msg - The parsed inbound message (from parseSlackEvent)
+ * @param botToken - Slack bot token for authenticated file download
+ * @returns The message with body replaced by transcript, or original on failure
+ */
+export declare function enrichVoiceMessage(msg: InboundMessage, botToken: string): Promise<InboundMessage>;

package/dist/channels/slack/inbound.js

@@ -0,0 +1,96 @@
+/**
+ * Slack inbound message parsing.
+ * Story 4.5
+ */
+import { transcribeAudio, downloadAudio } from "./transcribe.js";
+const AUDIO_TYPES = new Set(["aac", "mp4", "m4a", "ogg", "webm", "mp3", "wav"]);
+/**
+ * Extract the text content from a voice message file.
+ * Prefers the transcription preview; falls back to the file preview text.
+ * Returns null if the file is not a voice message or has no transcript.
+ */
+export function extractVoiceTranscript(file) {
+    const isAudio = file.subtype === "slack_audio" || AUDIO_TYPES.has(file.filetype ?? "");
+    if (!isAudio)
+        return null;
+    const transcript = file.transcription?.preview?.content ??
+        (typeof file.preview === "string" ? file.preview : null);
+    return transcript ?? null;
+}
+/**
+ * Parse a Slack event into an InboundMessage.
+ *
+ * Handles standard text messages and voice messages (file_share subtype
+ * with audio files). Voice message transcripts are extracted and prefixed
+ * with `[Voice message]`.
+ */
+export function parseSlackEvent(event) {
+    const id = event.client_msg_id ?? event.ts ?? event.event_ts ?? `slack-${Date.now()}`;
+    const channel = event.channel ?? "unknown";
+    const from = event.user ?? "unknown";
+    const threadId = event.thread_ts !== undefined ? event.thread_ts : undefined;
+    const receivedAt = event.ts
+        ? new Date(parseFloat(event.ts) * 1000).toISOString()
+        : new Date().toISOString();
+    let body = event.text ?? "";
+    // Voice messages: extract transcript from audio file attachments
+    if (event.subtype === "file_share" && event.files?.length) {
+        for (const file of event.files) {
+            const transcript = extractVoiceTranscript(file);
+            if (transcript) {
+                body = body ? `${body}\n\n[Voice message] ${transcript}` : `[Voice message] ${transcript}`;
+                break; // Only one voice message per event
+            }
+        }
+    }
+    // If voice message had no Slack transcript, mark for local transcription
+    if (event.subtype === "file_share" && event.files?.length && !body) {
+        const hasAudio = event.files.some((f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? ""));
+        if (hasAudio) {
+            body = "[Voice message — no transcript available]";
+        }
+    }
+    return {
+        id,
+        channel,
+        from,
+        body,
+        threadId,
+        receivedAt,
+        raw: event,
+    };
+}
+/**
+ * Enrich a voice message with local transcription when Slack's built-in
+ * transcription is unavailable.
+ *
+ * Downloads the audio file from Slack using the bot token, converts to WAV,
+ * and transcribes locally via whisper-node. Returns the original message
+ * unchanged if transcription fails or is not needed.
+ *
+ * @param msg - The parsed inbound message (from parseSlackEvent)
+ * @param botToken - Slack bot token for authenticated file download
+ * @returns The message with body replaced by transcript, or original on failure
+ */
+export async function enrichVoiceMessage(msg, botToken) {
+    if (!msg.body.includes("[Voice message — no transcript available]"))
+        return msg;
+    const raw = msg.raw;
+    const files = raw?.files;
+    if (!files?.length)
+        return msg;
+    const audioFile = files.find((f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? ""));
+    if (!audioFile?.url_private)
+        return msg;
+    const buffer = await downloadAudio(audioFile.url_private, botToken);
+    if (!buffer)
+        return msg;
+    const filename = audioFile.name ?? `voice.${audioFile.filetype ?? "aac"}`;
+    const transcript = await transcribeAudio(buffer, filename);
+    if (!transcript)
+        return msg;
+    return {
+        ...msg,
+        body: `[Voice message] ${transcript}`,
+    };
+}

package/dist/channels/slack/models.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slack channel configuration types.
+ * Story 4.5
+ */
+export interface SlackConfig {
+    botToken: string;
+    appToken?: string;
+    signingSecret?: string;
+}

package/dist/channels/slack/models.js

@@ -0,0 +1,5 @@
+/**
+ * Slack channel configuration types.
+ * Story 4.5
+ */
+export {};

package/dist/channels/slack/outbound.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Slack outbound formatting.
+ * Story 4.5
+ */
+/**
+ * Convert standard markdown to Slack's mrkdwn format.
+ * - **bold** → *bold*
+ * - _italic_ preserved
+ * - `code` preserved
+ * - ```code block``` preserved
+ */
+export declare function formatForSlack(text: string): string;

package/dist/channels/slack/outbound.js

@@ -0,0 +1,18 @@
+/**
+ * Slack outbound formatting.
+ * Story 4.5
+ */
+/**
+ * Convert standard markdown to Slack's mrkdwn format.
+ * - **bold** → *bold*
+ * - _italic_ preserved
+ * - `code` preserved
+ * - ```code block``` preserved
+ */
+export function formatForSlack(text) {
+    // **bold** → *bold*
+    let result = text.replace(/\*\*(.+?)\*\*/gs, "*$1*");
+    // __bold__ → *bold*
+    result = result.replace(/__(.+?)__/gs, "*$1*");
+    return result;
+}

package/dist/channels/slack/transcribe.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Local voice transcription via whisper-node (whisper.cpp bindings).
+ *
+ * whisper-node is an optional dependency — if not installed, transcription
+ * degrades gracefully (returns null). Requires ffmpeg on the system PATH
+ * for audio format conversion.
+ *
+ * Setup:
+ *   npm install whisper-node
+ *   npx whisper-node download    # download a model (e.g. base.en)
+ *   brew install ffmpeg           # or equivalent for your platform
+ */
+export interface TranscribeOptions {
+    /** Whisper model name (default: "base.en"). Run `npx whisper-node download` to get models. */
+    modelName?: string;
+    /** Language code (default: "auto"). Use "en" for English-only models. */
+    language?: string;
+}
+export interface TranscribeResult {
+    /** The full transcribed text */
+    text: string;
+    /** Individual segments with timestamps */
+    segments: Array<{
+        start: string;
+        end: string;
+        speech: string;
+    }>;
+}
+/**
+ * Transcribe an audio buffer using whisper-node.
+ *
+ * @param audioBuffer - Raw audio data (any format ffmpeg can decode)
+ * @param filename - Original filename (used for temp file extension)
+ * @param opts - Transcription options
+ * @returns Transcribed text, or null if transcription fails or whisper-node is not installed
+ */
+export declare function transcribeAudio(audioBuffer: Buffer, filename: string, opts?: TranscribeOptions): Promise<string | null>;
+/**
+ * Download an audio file from a URL with bearer token authentication.
+ */
+export declare function downloadAudio(url: string, token: string): Promise<Buffer | null>;