beecork 1.4.11 → 1.6.0

package/dist/channels/loader.js

@@ -37,7 +37,6 @@ export async function loadCommunityChannels(ctx) {
                     continue;
                 if (!allowlist.includes(dir))
                     continue;
-                const channelName = dir.slice(CHANNEL_PREFIX.length);
                 const pkgPath = path.join(searchPath, dir);
                 try {
                     // Read package.json to find the main entry
@@ -48,8 +47,15 @@ export async function loadCommunityChannels(ctx) {
                         logger.warn(`Community channel ${dir}: entry point not found at ${entryPath}`);
                         continue;
                     }
-                    // Dynamic import — community channels run with full daemon access
-                    logger.warn(`Loading community channel from ${dir} — ensure you trust this package`);
+                    // Dynamic import — community channels run with full daemon access:
+                    // they can read every config token (Telegram, Discord, WhatsApp,
+                    // notification provider keys) AND every environment variable the
+                    // daemon inherits (including SSH-agent sockets, GitHub tokens,
+                    // anything sourced from your shell profile). A compromised
+                    // community-channel package is effectively a root credential drop.
+                    // Pin versions in package.json, audit before opting in, and treat
+                    // every entry in `communityChannels` as a trust anchor.
+                    logger.warn(`Loading community channel "${dir}" — this package will have FULL access to your channel tokens (Telegram/Discord/WhatsApp) and every environment variable inherited by the daemon (including SSH keys). Only enable if you trust the package author and have audited the version.`);
                     const module = await import(entryPath);
                     const ChannelClass = module.default || module[Object.keys(module)[0]];
                     if (!ChannelClass || typeof ChannelClass !== 'function') {
@@ -58,7 +64,10 @@ export async function loadCommunityChannels(ctx) {
                     }
                     const instance = new ChannelClass(ctx);
                     // Validate it implements Channel interface (duck typing)
-                    if (!instance.id || !instance.name || typeof instance.start !== 'function' || typeof instance.stop !== 'function') {
+                    if (!instance.id ||
+                        !instance.name ||
+                        typeof instance.start !== 'function' ||
+                        typeof instance.stop !== 'function') {
                         logger.warn(`Community channel ${dir}: does not implement Channel interface`);
                         continue;
                     }

package/dist/channels/pipeline.js

@@ -22,9 +22,20 @@ import { logger } from '../util/logger.js';
 export async function processInboundMessage(opts) {
     const { text, media, channelId, tabManager, voiceReplyMode, ttsProvider, userId, sendProgress, overrideTabName, onTextChunk, } = opts;
     // 1. Parse tab name and prompt from the message text
-    let { tabName, prompt: rawPrompt } = parseTabMessage(text);
-    // Allow channel to override tab name (group tabs, thread tabs, etc.)
+    const parsed = parseTabMessage(text);
+    const rawPrompt = parsed.prompt;
+    let tabName = parsed.tabName;
+    // Allow channel to override tab name (group tabs, thread tabs, etc.).
+    // Validate centrally so each channel doesn't need its own check — keeps the
+    // CLAUDE.md "validation is centralized" rule honest. `default` is allowed.
     if (overrideTabName) {
+        if (overrideTabName !== 'default') {
+            const { validateTabName } = await import('../config.js');
+            const overrideErr = validateTabName(overrideTabName);
+            if (overrideErr) {
+                return { responseText: `Invalid tab name: ${overrideErr}`, tabName, isError: true };
+            }
+        }
         tabName = overrideTabName;
     }
     if (!rawPrompt && media.length === 0) {
@@ -56,9 +67,7 @@ export async function processInboundMessage(opts) {
     progressTracker.stop();
     // 6. Build response text
     const isError = result.error;
-    const responseText = isError
-        ? `Error: ${result.text}`
-        : result.text || '(empty response)';
+    const responseText = isError ? `Error: ${result.text}` : result.text || '(empty response)';
     // 7. TTS voice reply (shared logic)
     let audioPath;
     let voiceOnly = false;

package/dist/channels/registry.d.ts

@@ -1,4 +1,5 @@
 import type { Channel } from './types.js';
+import type { MediaAttachment } from '../types.js';
 /**
  * ChannelRegistry manages the lifecycle of all channels.
  * Channels register themselves, and the registry handles start/stop/broadcast.
@@ -7,7 +8,12 @@ export declare class ChannelRegistry {
     private channels;
     /** Register a channel */
     register(channel: Channel): void;
-    /** Start all registered channels */
+    /**
+     * Start all registered channels in parallel. Each channel's start() is an
+     * independent network handshake (Telegram getMe, Discord login, WhatsApp
+     * Baileys boot) — running them sequentially adds 2-5s to cold start with no
+     * coordination benefit.
+     */
     start(): Promise<void>;
     /** Stop all channels */
     stop(): void;
@@ -17,4 +23,14 @@ export declare class ChannelRegistry {
     getAll(): Channel[];
     /** Broadcast a notification to all channels */
     broadcastNotify(text: string, urgent?: boolean): Promise<void>;
+    /**
+     * Broadcast a media attachment to every channel that supports it. Used by
+     * the pending-message dispatcher to deliver media queued by
+     * `beecork_send_media` and the `beecork_generate_*` tools — without this,
+     * those tools queue a row whose JSON envelope is never rendered.
+     *
+     * Channels that don't implement broadcastMedia get a sendNotification
+     * fallback so the user at least learns a file was generated.
+     */
+    broadcastMedia(media: MediaAttachment): Promise<void>;
 }

package/dist/channels/registry.js

@@ -13,9 +13,14 @@ export class ChannelRegistry {
         this.channels.set(channel.id, channel);
         logger.info(`Channel registered: ${channel.name} (${channel.id})`);
     }
-    /** Start all registered channels */
+    /**
+     * Start all registered channels in parallel. Each channel's start() is an
+     * independent network handshake (Telegram getMe, Discord login, WhatsApp
+     * Baileys boot) — running them sequentially adds 2-5s to cold start with no
+     * coordination benefit.
+     */
     async start() {
-        for (const [id, channel] of this.channels) {
+        await Promise.all(Array.from(this.channels.entries()).map(async ([id, channel]) => {
             try {
                 await channel.start();
                 logger.info(`Channel started: ${channel.name}`);
@@ -23,7 +28,7 @@ export class ChannelRegistry {
             catch (err) {
                 logger.error(`Failed to start channel ${id}:`, err);
             }
-        }
+        }));
     }
     /** Stop all channels */
     stop() {
@@ -46,6 +51,30 @@ export class ChannelRegistry {
     }
     /** Broadcast a notification to all channels */
     async broadcastNotify(text, urgent) {
-        await Promise.all(Array.from(this.channels.values()).map(channel => channel.sendNotification(text, urgent).catch(err => logger.warn(`${channel.name} notify failed:`, err))));
+        await Promise.all(Array.from(this.channels.values()).map((channel) => channel
+            .sendNotification(text, urgent)
+            .catch((err) => logger.warn(`${channel.name} notify failed:`, err))));
+    }
+    /**
+     * Broadcast a media attachment to every channel that supports it. Used by
+     * the pending-message dispatcher to deliver media queued by
+     * `beecork_send_media` and the `beecork_generate_*` tools — without this,
+     * those tools queue a row whose JSON envelope is never rendered.
+     *
+     * Channels that don't implement broadcastMedia get a sendNotification
+     * fallback so the user at least learns a file was generated.
+     */
+    async broadcastMedia(media) {
+        await Promise.all(Array.from(this.channels.values()).map((channel) => {
+            if (channel.broadcastMedia) {
+                return channel
+                    .broadcastMedia(media)
+                    .catch((err) => logger.warn(`${channel.name} broadcastMedia failed:`, err));
+            }
+            const fallback = `📎 Media generated: ${media.filePath}${media.caption ? `\n${media.caption}` : ''}`;
+            return channel
+                .sendNotification(fallback)
+                .catch((err) => logger.warn(`${channel.name} media-fallback notify failed:`, err));
+        }));
     }
 }

package/dist/channels/send-helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Send a tab-prefixed, chunked, retried response through any channel.
+ *
+ * Each channel just provides:
+ *   - sendChunk(text): the platform-specific send call for one chunk
+ *   - maxLength:       the platform's per-message limit
+ *   - retryLabel:      label for logger (e.g. "telegram-send")
+ *
+ * Replaces near-identical per-channel implementations that had already
+ * drifted in subtle ways (different prefix gates, different retry envelopes).
+ */
+export declare function sendChunkedResponse(opts: {
+    text: string;
+    tabName?: string;
+    maxLength: number;
+    retryLabel: string;
+    retryDelays?: number[];
+    sendChunk: (chunk: string) => Promise<unknown>;
+}): Promise<void>;

package/dist/channels/send-helpers.js

@@ -0,0 +1,21 @@
+import { chunkText, formatTabbedResponse } from '../util/text.js';
+import { retryWithBackoff } from '../util/retry.js';
+/**
+ * Send a tab-prefixed, chunked, retried response through any channel.
+ *
+ * Each channel just provides:
+ *   - sendChunk(text): the platform-specific send call for one chunk
+ *   - maxLength:       the platform's per-message limit
+ *   - retryLabel:      label for logger (e.g. "telegram-send")
+ *
+ * Replaces near-identical per-channel implementations that had already
+ * drifted in subtle ways (different prefix gates, different retry envelopes).
+ */
+export async function sendChunkedResponse(opts) {
+    const full = formatTabbedResponse(opts.text, opts.tabName);
+    const chunks = chunkText(full, opts.maxLength);
+    const delays = opts.retryDelays ?? [1000, 5000, 15000];
+    for (const chunk of chunks) {
+        await retryWithBackoff(() => opts.sendChunk(chunk), delays, opts.retryLabel);
+    }
+}

package/dist/channels/telegram.d.ts

@@ -1,38 +1,45 @@
-import type { Channel, ChannelContext, InboundMessageHandler, SendOptions } from './types.js';
-/** Format tab status for Telegram display */
-export declare function formatTabStatus(tabs: Array<{
-    name: string;
-    status: string;
-    lastActivityAt: string;
-}>): string;
+import type { Channel, ChannelContext, MediaAttachment, SendOptions } from './types.js';
 export declare class TelegramChannel implements Channel {
     readonly id = "telegram";
     readonly name = "Telegram";
     readonly maxMessageLength = 4096;
-    readonly supportsStreaming = true;
-    readonly supportsMedia = true;
     private bot;
     private ctx;
     private activeChatIds;
-    private sttProvider;
-    private ttsProvider;
+    private allowedUserIdSet;
+    private voice;
     private botUserId;
     private botUsername;
     private mutedGroups;
     private welcomeSent;
-    private sttWarmedUp;
+    private pollingErrorTimes;
+    private pollingDegradedNotified;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
+    /**
+     * Track polling errors over a 60s rolling window. If we see 5+ errors in 60s
+     * we surface "polling degraded" exactly once via the notify callback so the
+     * user knows Telegram is broken instead of silently failing.
+     */
+    private recordPollingError;
     stop(): void;
-    sendMessage(peerId: string, text: string, options?: SendOptions): Promise<void>;
+    sendMessage(peerId: string, text: string, _options?: SendOptions): Promise<void>;
     sendNotification(message: string, _urgent?: boolean): Promise<void>;
+    /**
+     * Send a media file to every recipient the bot would notify. Used by the
+     * pending-message dispatcher to deliver media queued by MCP tools.
+     * Routes by attachment type to the right Telegram primitive (sendVoice for
+     * voice messages, sendPhoto for images, sendVideo for video, sendDocument
+     * for everything else).
+     */
+    broadcastMedia(media: MediaAttachment): Promise<void>;
     setTyping(peerId: string, active: boolean): Promise<void>;
-    onMessage(_handler: InboundMessageHandler): void;
     private setupHandlers;
     private handleCommand;
     private handleMessage;
     private sendResponse;
     private sendWithRetry;
+    private sendWithRetryRaw;
     private downloadTelegramFile;
     private isAllowed;
     private isAdmin;