botinabox 2.5.1 → 2.5.2

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/index.d.ts

@@ -1,5 +1,5 @@
 import { C as ChannelAdapter, c as ChannelMeta, a as ChannelCapabilities, I as InboundMessage, b as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-06G0vbIn.js';
-import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-BWrtVqEP.js';
+import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-DuNX5WoL.js';
 import 'better-sqlite3';
 import '../../provider-DLGUfnNx.js';
 

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>;

package/dist/channels/slack/transcribe.js

@@ -0,0 +1,106 @@
+/**
+ * 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
+ */
+import { execFileSync } from "node:child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { createRequire } from "node:module";
+const TEMP_DIR = join(os.tmpdir(), "botinabox-audio");
+/**
+ * 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 async function transcribeAudio(audioBuffer, filename, opts) {
+    // Lazy-load whisper-node (optional CJS dependency)
+    let whisper;
+    try {
+        const require = createRequire(import.meta.url);
+        const mod = require("whisper-node");
+        whisper = mod.whisper ?? mod.default ?? mod;
+    }
+    catch {
+        console.warn("[botinabox] whisper-node not installed — voice transcription unavailable. Run: npm install whisper-node && npx whisper-node download");
+        return null;
+    }
+    // Check ffmpeg availability
+    try {
+        execFileSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    }
+    catch {
+        console.warn("[botinabox] ffmpeg not found — required for audio conversion. Install: brew install ffmpeg");
+        return null;
+    }
+    const id = randomUUID().slice(0, 8);
+    const ext = filename.split(".").pop() ?? "aac";
+    mkdirSync(TEMP_DIR, { recursive: true });
+    const inputPath = join(TEMP_DIR, `${id}.${ext}`);
+    const wavPath = join(TEMP_DIR, `${id}.wav`);
+    try {
+        // Write audio to temp file
+        writeFileSync(inputPath, audioBuffer);
+        // Convert to WAV 16kHz mono PCM (required by whisper.cpp)
+        execFileSync("ffmpeg", ["-y", "-i", inputPath, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", wavPath], {
+            stdio: "ignore",
+            timeout: 30_000,
+        });
+        // Transcribe
+        const segments = await whisper(wavPath, {
+            modelName: opts?.modelName ?? "base.en",
+            whisperOptions: {
+                language: opts?.language ?? "auto",
+            },
+        });
+        if (!segments || segments.length === 0)
+            return null;
+        return segments.map((s) => s.speech).join(" ").trim();
+    }
+    catch (err) {
+        console.error("[botinabox] Transcription failed:", err);
+        return null;
+    }
+    finally {
+        // Clean up temp files
+        try {
+            unlinkSync(inputPath);
+        }
+        catch { /* ignore */ }
+        try {
+            unlinkSync(wavPath);
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Download an audio file from a URL with bearer token authentication.
+ */
+export async function downloadAudio(url, token) {
+    try {
+        const resp = await fetch(url, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!resp.ok) {
+            console.error(`[botinabox] Audio download failed: ${resp.status} ${resp.statusText}`);
+            return null;
+        }
+        return Buffer.from(await resp.arrayBuffer());
+    }
+    catch (err) {
+        console.error("[botinabox] Audio download error:", err);
+        return null;
+    }
+}

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

@@ -0,0 +1,23 @@
+/**
+ * WebhookAdapter — ChannelAdapter implementation for webhook-based channels.
+ * Story 4.7
+ */
+import type { ChannelAdapter, ChannelCapabilities, ChannelMeta, ChannelConfig, InboundMessage, OutboundPayload, SendResult, HealthStatus } from "../../shared/index.js";
+export declare class WebhookAdapter implements ChannelAdapter {
+    readonly id = "webhook";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private webhookServer;
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+}
+/** Factory function — default export for auto-discovery. */
+export default function createWebhookAdapter(): WebhookAdapter;

package/dist/channels/webhook/adapter.js

@@ -0,0 +1,86 @@
+/**
+ * WebhookAdapter — ChannelAdapter implementation for webhook-based channels.
+ * Story 4.7
+ */
+import { WebhookServer } from "./server.js";
+export class WebhookAdapter {
+    id = "webhook";
+    meta = {
+        displayName: "Webhook",
+        homepage: "https://example.com",
+    };
+    capabilities = {
+        chatTypes: ["direct"],
+        threads: false,
+        reactions: false,
+        editing: false,
+        media: false,
+        polls: false,
+        maxTextLength: 65535,
+        formattingMode: "plain",
+    };
+    onMessage;
+    connected = false;
+    config = null;
+    webhookServer = null;
+    async connect(config) {
+        this.config = config;
+        this.connected = true;
+        // Start webhook HTTP server if port is specified
+        if (this.config.port) {
+            this.webhookServer = new WebhookServer({
+                port: this.config.port,
+                secret: this.config.secret,
+                onMessage: async (msg) => {
+                    if (this.onMessage)
+                        await this.onMessage(msg);
+                },
+            });
+            await this.webhookServer.start();
+        }
+    }
+    async disconnect() {
+        if (this.webhookServer) {
+            await this.webhookServer.stop();
+            this.webhookServer = null;
+        }
+        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 callbackUrl = this.config?.callbackUrl;
+        if (!callbackUrl) {
+            // No callback URL configured — accept silently (fire-and-forget style)
+            return { success: true };
+        }
+        try {
+            const body = JSON.stringify({
+                to: target.peerId,
+                threadId: target.threadId,
+                text: payload.text,
+            });
+            const response = await fetch(callbackUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body,
+            });
+            if (response.ok) {
+                return { success: true };
+            }
+            return { success: false, error: `HTTP ${response.status}` };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
+}
+/** Factory function — default export for auto-discovery. */
+export default function createWebhookAdapter() {
+    return new WebhookAdapter();
+}

package/dist/channels/webhook/hmac.d.ts

@@ -0,0 +1,13 @@
+/**
+ * HMAC signature verification for webhook payloads.
+ * Story 4.7
+ */
+/**
+ * Verify that the HMAC-SHA256 signature of body matches the provided signature.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param body      - The raw request body string
+ * @param secret    - The shared HMAC secret
+ * @param signature - The signature to verify (hex string, possibly prefixed with "sha256=")
+ */
+export declare function verifyHmac(body: string, secret: string, signature: string): boolean;

package/dist/channels/webhook/hmac.js

@@ -0,0 +1,26 @@
+/**
+ * HMAC signature verification for webhook payloads.
+ * Story 4.7
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+/**
+ * Verify that the HMAC-SHA256 signature of body matches the provided signature.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param body      - The raw request body string
+ * @param secret    - The shared HMAC secret
+ * @param signature - The signature to verify (hex string, possibly prefixed with "sha256=")
+ */
+export function verifyHmac(body, secret, signature) {
+    const expected = createHmac("sha256", secret).update(body, "utf8").digest("hex");
+    // Strip optional "sha256=" prefix
+    const provided = signature.startsWith("sha256=") ? signature.slice(7) : signature;
+    if (expected.length !== provided.length)
+        return false;
+    try {
+        return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(provided, "hex"));
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Webhook channel configuration types.
+ * Story 4.7
+ */
+export interface WebhookConfig {
+    callbackUrl?: string;
+    secret?: string;
+    port?: number;
+}

package/dist/channels/webhook/models.js

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