beecork 1.7.0 → 2.0.0

package/dist/channels/types.d.ts

@@ -1,41 +0,0 @@
-import type { TabManager } from '../session/manager.js';
-import type { BeecorkConfig, MediaAttachment } from '../types.js';
-export type { MediaAttachment };
-/**
- * Options for sending a message. Currently empty — channels do not honor
- * markdown/reply-threading hints. Kept as a placeholder so future per-channel
- * options can be added without touching every call site.
- */
-export type SendOptions = Record<string, never>;
-/** The Channel interface — all channels must implement this */
-export interface Channel {
-    /** Unique channel identifier (e.g., 'telegram', 'whatsapp', 'discord') */
-    readonly id: string;
-    /** Human-readable name */
-    readonly name: string;
-    /** Maximum message length in characters */
-    readonly maxMessageLength: number;
-    /** Start the channel (connect, start polling, etc.) */
-    start(): Promise<void>;
-    /** Stop the channel gracefully */
-    stop(): void;
-    /** Send a text message to a specific peer */
-    sendMessage(peerId: string, text: string, options?: SendOptions): Promise<void>;
-    /** Send a media attachment to a peer (optional — channels implement when supported) */
-    sendMedia?(peerId: string, media: MediaAttachment): Promise<void>;
-    /** Send a notification to all configured recipients */
-    sendNotification(message: string, urgent?: boolean): Promise<void>;
-    /** Set typing indicator for a peer */
-    setTyping(peerId: string, active: boolean): Promise<void>;
-    /** Broadcast a media file to every configured recipient — used by the
-     * pending-message dispatcher to deliver MCP-queued media. Optional; channels
-     * that don't implement it fall back to sendNotification with a text summary. */
-    broadcastMedia?(media: MediaAttachment): Promise<void>;
-}
-/** Context passed to channels during construction */
-export interface ChannelContext {
-    config: BeecorkConfig;
-    tabManager: TabManager;
-    /** Broadcast notification to all channels + notification providers */
-    notifyCallback?: (message: string) => Promise<void>;
-}

package/dist/channels/types.js

@@ -1 +0,0 @@
-export {};

package/dist/channels/voice-state.d.ts

@@ -1,29 +0,0 @@
-import type { STTProvider } from '../voice/stt.js';
-import type { TTSProvider } from '../voice/tts.js';
-import type { VoiceConfig, BeecorkConfig } from '../types.js';
-import type { MediaAttachment } from '../types.js';
-/**
- * Per-channel STT/TTS state. Used to be duplicated across Telegram, WhatsApp,
- * and Discord; consolidated here so init + warmup + transcription happen the
- * same way across all 3.
- *
- * Discord historically only called warmup() and did NOT transcribe — preserve
- * that behavior unless the caller explicitly asks for transcription.
- */
-export declare class VoiceState {
-    private readonly channelId;
-    stt: STTProvider | null;
-    tts: TTSProvider | null;
-    private warmedUp;
-    constructor(channelId: string);
-    init(config: BeecorkConfig | {
-        voice?: VoiceConfig;
-    }): void;
-    /** One-shot warmup (no media). Used by Discord today. */
-    warmup(): Promise<void>;
-    /**
-     * Transcribe voice attachments in-place (mutates the caption fields).
-     * Returns the updated warmed-up flag. No-op if STT isn't configured.
-     */
-    transcribe(media: MediaAttachment[]): Promise<void>;
-}

package/dist/channels/voice-state.js

@@ -1,45 +0,0 @@
-import { initVoiceProviders } from '../voice/index.js';
-/**
- * Per-channel STT/TTS state. Used to be duplicated across Telegram, WhatsApp,
- * and Discord; consolidated here so init + warmup + transcription happen the
- * same way across all 3.
- *
- * Discord historically only called warmup() and did NOT transcribe — preserve
- * that behavior unless the caller explicitly asks for transcription.
- */
-export class VoiceState {
-    channelId;
-    stt = null;
-    tts = null;
-    warmedUp = false;
-    constructor(channelId) {
-        this.channelId = channelId;
-    }
-    init(config) {
-        const { stt, tts } = initVoiceProviders(config.voice);
-        this.stt = stt;
-        this.tts = tts;
-    }
-    /** One-shot warmup (no media). Used by Discord today. */
-    async warmup() {
-        if (this.warmedUp || !this.stt)
-            return;
-        try {
-            this.stt.warmup?.();
-        }
-        catch {
-            /* warmup is best-effort */
-        }
-        this.warmedUp = true;
-    }
-    /**
-     * Transcribe voice attachments in-place (mutates the caption fields).
-     * Returns the updated warmed-up flag. No-op if STT isn't configured.
-     */
-    async transcribe(media) {
-        if (!this.stt)
-            return;
-        const { transcribeVoiceMessages } = await import('../voice/index.js');
-        this.warmedUp = await transcribeVoiceMessages(media, this.stt, this.channelId, this.warmedUp);
-    }
-}

package/dist/channels/webhook.d.ts

@@ -1,16 +0,0 @@
-import type { Channel, ChannelContext, SendOptions } from './types.js';
-export declare class WebhookChannel implements Channel {
-    readonly id = "webhook";
-    readonly name = "Webhook";
-    readonly maxMessageLength: 100000;
-    private server;
-    private ctx;
-    constructor(ctx: ChannelContext);
-    start(): Promise<void>;
-    stop(): void;
-    sendMessage(_peerId: string, _text: string, _options?: SendOptions): Promise<void>;
-    sendNotification(_message: string, _urgent?: boolean): Promise<void>;
-    setTyping(_peerId: string, _active: boolean): Promise<void>;
-    private authenticate;
-    private getConfig;
-}

package/dist/channels/webhook.js

@@ -1,222 +0,0 @@
-import http from 'node:http';
-import crypto from 'node:crypto';
-import { logger } from '../util/logger.js';
-import { validateTabNameOrDefault } from '../config.js';
-import { inboundLimiter } from '../util/rate-limiter.js';
-import { MESSAGE_LIMITS } from '../util/text.js';
-import { processInboundMessage } from './pipeline.js';
-function safeEqualString(a, b) {
-    const ab = Buffer.from(a);
-    const bb = Buffer.from(b);
-    if (ab.length !== bb.length)
-        return false;
-    try {
-        return crypto.timingSafeEqual(ab, bb);
-    }
-    catch {
-        return false;
-    }
-}
-export class WebhookChannel {
-    id = 'webhook';
-    name = 'Webhook';
-    maxMessageLength = MESSAGE_LIMITS.WEBHOOK_PROMPT;
-    server = null;
-    ctx;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    async start() {
-        const config = this.getConfig();
-        if (!config?.enabled)
-            return;
-        // Fail-secure: a webhook running with no auth turns localhost-injected
-        // prompts (from any local process or any user on a shared host) into
-        // arbitrary claude --dangerously-skip-permissions runs. Require either
-        // an authToken or hmacSecret, OR an explicit allowUnauthLocalhost opt-in.
-        if (!config.authToken && !config.hmacSecret && !config.allowUnauthLocalhost) {
-            logger.error('Webhook channel refusing to start: no authToken or hmacSecret configured. ' +
-                'Set one in ~/.beecork/config.json under webhook.authToken/hmacSecret, or ' +
-                'explicitly opt in with webhook.allowUnauthLocalhost=true (NOT recommended on shared hosts).');
-            return;
-        }
-        const port = config.port || 8374;
-        this.server = http.createServer(async (req, res) => {
-            // CORS headers for API clients
-            res.setHeader('Content-Type', 'application/json');
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-            if (req.method !== 'POST') {
-                res.writeHead(405);
-                res.end(JSON.stringify({ error: 'Method not allowed' }));
-                return;
-            }
-            // Parse URL
-            const url = new URL(req.url || '/', `http://localhost:${port}`);
-            const match = url.pathname.match(/^\/webhook\/(.+)$/);
-            if (!match) {
-                res.writeHead(404);
-                res.end(JSON.stringify({ error: 'Use POST /webhook/:tabName' }));
-                return;
-            }
-            const tabName = decodeURIComponent(match[1]);
-            // Validate tab name (allow "default" — it's a reference, not a creation)
-            const tabError = validateTabNameOrDefault(tabName);
-            if (tabError) {
-                res.writeHead(400);
-                res.end(JSON.stringify({ error: tabError }));
-                return;
-            }
-            // Read body first (needed for both JSON parsing and HMAC verification)
-            let body = '';
-            for await (const chunk of req) {
-                body += chunk;
-                if (body.length > MESSAGE_LIMITS.HTTP_BODY) {
-                    res.writeHead(413);
-                    res.end(JSON.stringify({ error: 'Payload too large' }));
-                    req.destroy();
-                    return;
-                }
-            }
-            // Auth check (after body read, so HMAC can verify body)
-            if (!this.authenticate(req, config, body)) {
-                res.writeHead(401);
-                res.end(JSON.stringify({ error: 'Unauthorized' }));
-                return;
-            }
-            // Rate-limit AFTER auth so unauthenticated callers don't burn the budget
-            if (!inboundLimiter.check(this.id)) {
-                res.writeHead(429);
-                res.end(JSON.stringify({ error: 'Rate limit exceeded' }));
-                return;
-            }
-            let payload;
-            try {
-                payload = JSON.parse(body);
-            }
-            catch {
-                res.writeHead(400);
-                res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                return;
-            }
-            const prompt = payload.prompt || payload.message || '';
-            if (!prompt) {
-                res.writeHead(400);
-                res.end(JSON.stringify({ error: 'Missing "prompt" or "message" field' }));
-                return;
-            }
-            const isSync = payload.sync ?? false;
-            const remote = req.socket.remoteAddress ?? 'webhook';
-            try {
-                if (isSync) {
-                    // Sync mode: route through the shared pipeline so routing/enrichment apply.
-                    const result = await processInboundMessage({
-                        text: prompt,
-                        media: [],
-                        channelId: this.id,
-                        tabManager: this.ctx.tabManager,
-                        userId: remote,
-                        sendProgress: () => {
-                            /* webhook has no progress channel */
-                        },
-                        overrideTabName: tabName,
-                    });
-                    res.writeHead(result.isError ? 500 : 200);
-                    res.end(JSON.stringify({
-                        text: result.responseText,
-                        tab: result.tabName,
-                        error: result.isError ? result.responseText : undefined,
-                    }));
-                }
-                else {
-                    // Async mode: fire-and-forget through the pipeline.
-                    // Surface failures to the user via broadcastNotify since the HTTP response
-                    // is already 202 and the caller has no other way to learn.
-                    processInboundMessage({
-                        text: prompt,
-                        media: [],
-                        channelId: this.id,
-                        tabManager: this.ctx.tabManager,
-                        userId: remote,
-                        sendProgress: () => {
-                            /* webhook has no progress channel */
-                        },
-                        overrideTabName: tabName,
-                    })
-                        .then((result) => {
-                        if (result.isError && this.ctx.notifyCallback) {
-                            this.ctx
-                                .notifyCallback(`Webhook async failed for "${tabName}": ${result.responseText}`)
-                                .catch(() => { });
-                        }
-                    })
-                        .catch((err) => {
-                        logger.error(`Webhook async processing failed for tab ${tabName}:`, err);
-                        if (this.ctx.notifyCallback) {
-                            this.ctx
-                                .notifyCallback(`Webhook async failed for "${tabName}": ${err instanceof Error ? err.message : String(err)}`)
-                                .catch(() => { });
-                        }
-                    });
-                    res.writeHead(202);
-                    res.end(JSON.stringify({ accepted: true, tab: tabName }));
-                }
-            }
-            catch (err) {
-                logger.error('Webhook handler error:', err);
-                res.writeHead(500);
-                res.end(JSON.stringify({ error: 'Internal error' }));
-            }
-        });
-        this.server.listen(port, '127.0.0.1', () => {
-            logger.info(`Webhook channel listening on http://127.0.0.1:${port}/webhook/:tabName`);
-        });
-    }
-    stop() {
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
-        logger.info('Webhook channel stopped');
-    }
-    async sendMessage(_peerId, _text, _options) {
-        // Webhooks are request-response — responses are sent in the HTTP handler
-    }
-    async sendNotification(_message, _urgent) {
-        // Webhook channel doesn't have persistent connections to send notifications to
-    }
-    async setTyping(_peerId, _active) {
-        // No typing indicators for webhooks
-    }
-    authenticate(req, config, body) {
-        // No auth configured = allow all (localhost only)
-        if (!config.authToken && !config.hmacSecret)
-            return true;
-        // Bearer token auth (constant-time compare)
-        if (config.authToken) {
-            const authHeader = req.headers.authorization || '';
-            if (safeEqualString(authHeader, `Bearer ${config.authToken}`))
-                return true;
-        }
-        // HMAC signature auth (for GitHub-style webhooks)
-        if (config.hmacSecret) {
-            const signature = req.headers['x-hub-signature-256'];
-            if (signature) {
-                const expected = 'sha256=' + crypto.createHmac('sha256', config.hmacSecret).update(body).digest('hex');
-                try {
-                    return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
-                }
-                catch {
-                    return false; // Length mismatch or encoding error
-                }
-            }
-        }
-        return false;
-    }
-    getConfig() {
-        return this.ctx.config.webhook;
-    }
-}

package/dist/channels/whatsapp.d.ts

@@ -1,28 +0,0 @@
-import type { Channel, ChannelContext, SendOptions } from './types.js';
-export declare class WhatsAppChannel implements Channel {
-    readonly id = "whatsapp";
-    readonly name = "WhatsApp";
-    readonly maxMessageLength = 8192;
-    private sock;
-    private ctx;
-    private allowedNumbers;
-    private reconnectAttempts;
-    private readonly maxReconnectAttempts;
-    private readonly backoffDelays;
-    private voice;
-    constructor(ctx: ChannelContext);
-    /**
-     * Schedule the next reconnect with exponential backoff. Unlike the previous
-     * inline setTimeout, this path retries when `start()` itself rejects (auth
-     * failure, baileys init throw, etc.) instead of going permanently silent
-     * after a single failed attempt.
-     */
-    private scheduleReconnect;
-    start(): Promise<void>;
-    stop(): void;
-    sendMessage(peerId: string, text: string, _options?: SendOptions): Promise<void>;
-    sendNotification(message: string, _urgent?: boolean): Promise<void>;
-    setTyping(peerId: string, active: boolean): Promise<void>;
-    private sendResponse;
-    private isAllowed;
-}