beecork 1.7.1 → 2.0.1

package/dist/util/logger.js

@@ -1,118 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { getLogsDir } from './paths.js';
-const LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-// Patterns that should never reach disk or stdout. Each channel uses a per-call
-// sanitizer too (defense-in-depth), but the Logger is the last line of defense
-// for any third-party error object that happens to embed a secret in its message.
-const REDACTION_PATTERNS = [
-    { re: /bot\d+:[A-Za-z0-9_-]+/g, replacement: 'bot<REDACTED>' }, // Telegram bot token
-];
-function redact(s) {
-    let out = s;
-    for (const { re, replacement } of REDACTION_PATTERNS)
-        out = out.replace(re, replacement);
-    return out;
-}
-const ROTATE_BYTES = 10 * 1024 * 1024;
-class Logger {
-    minLevel = 'info';
-    logFile = null;
-    stream = null;
-    bytesWritten = 0;
-    setLevel(level) {
-        this.minLevel = level;
-    }
-    setLogFile(name) {
-        const dir = getLogsDir();
-        fs.mkdirSync(dir, { recursive: true });
-        this.logFile = path.join(dir, name);
-        this.stream = fs.createWriteStream(this.logFile, { flags: 'a' });
-        // Seed bytesWritten from the existing file size so we don't reset the
-        // rotation counter on every daemon restart.
-        try {
-            this.bytesWritten = fs.statSync(this.logFile).size;
-        }
-        catch {
-            this.bytesWritten = 0;
-        }
-    }
-    write(level, msg, ...args) {
-        if (LEVEL_PRIORITY[level] < LEVEL_PRIORITY[this.minLevel])
-            return;
-        const timestamp = new Date().toISOString();
-        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
-        const raw = args.length > 0
-            ? `${prefix} ${msg} ${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}`
-            : `${prefix} ${msg}`;
-        const line = redact(raw);
-        if (this.stream) {
-            const out = line + '\n';
-            this.stream.write(out);
-            this.bytesWritten += out.length;
-            if (this.bytesWritten > ROTATE_BYTES)
-                this.checkRotation();
-        }
-        if (level === 'error') {
-            console.error(line);
-        }
-        else if (level === 'warn') {
-            console.warn(line);
-        }
-        else if (level !== 'debug') {
-            console.log(line);
-        }
-    }
-    debug(msg, ...args) {
-        this.write('debug', msg, ...args);
-    }
-    info(msg, ...args) {
-        this.write('info', msg, ...args);
-    }
-    warn(msg, ...args) {
-        this.write('warn', msg, ...args);
-    }
-    error(msg, ...args) {
-        this.write('error', msg, ...args);
-    }
-    checkRotation() {
-        if (!this.logFile || !this.stream)
-            return;
-        // bytesWritten-based gate already triggered us; rotate without statSync.
-        try {
-            this.stream.end();
-            const rotated = this.logFile + '.1';
-            try {
-                fs.unlinkSync(rotated);
-            }
-            catch {
-                /* not fatal */
-            }
-            fs.renameSync(this.logFile, rotated);
-            this.stream = fs.createWriteStream(this.logFile, { flags: 'a' });
-            this.bytesWritten = 0;
-        }
-        catch {
-            /* rotation failure shouldn't kill the daemon */
-        }
-    }
-    close() {
-        if (this.stream) {
-            this.stream.end();
-            this.stream = null;
-        }
-    }
-}
-export const logger = new Logger();
-// Allow operators to bump verbosity at runtime without recompiling.
-// e.g. `BEECORK_LOG_LEVEL=debug beecork start` surfaces every claude subprocess
-// stdout/stderr line via the logger.debug calls.
-const envLevel = process.env.BEECORK_LOG_LEVEL?.toLowerCase();
-if (envLevel === 'debug' || envLevel === 'info' || envLevel === 'warn' || envLevel === 'error') {
-    logger.setLevel(envLevel);
-}

package/dist/util/paths.d.ts

@@ -1,13 +0,0 @@
-export declare function getBeecorkHome(): string;
-export declare function getConfigPath(): string;
-export declare function getDbPath(): string;
-export declare function getCrontabPath(): string;
-export declare function getMcpConfigPath(): string;
-export declare function getLogsDir(): string;
-export declare function getPidPath(): string;
-export declare function getRuntimeInfoPath(): string;
-export declare function getCronReloadSignalPath(): string;
-export declare function getWatcherReloadSignalPath(): string;
-export declare function getWhatsappSessionPath(): string;
-export declare function ensureBeecorkDirs(): void;
-export declare function expandHome(p: string): string;

package/dist/util/paths.js

@@ -1,55 +0,0 @@
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-const BEECORK_DIR = '.beecork';
-export function getBeecorkHome() {
-    return process.env.BEECORK_HOME || path.join(os.homedir(), BEECORK_DIR);
-}
-export function getConfigPath() {
-    return path.join(getBeecorkHome(), 'config.json');
-}
-export function getDbPath() {
-    return path.join(getBeecorkHome(), 'memory.db');
-}
-export function getCrontabPath() {
-    return path.join(getBeecorkHome(), 'crontab.json');
-}
-export function getMcpConfigPath() {
-    return path.join(getBeecorkHome(), 'mcp-config.json');
-}
-export function getLogsDir() {
-    return path.join(getBeecorkHome(), 'logs');
-}
-export function getPidPath() {
-    return path.join(getBeecorkHome(), 'beecork.pid');
-}
-export function getRuntimeInfoPath() {
-    return path.join(getBeecorkHome(), 'runtime.json');
-}
-export function getCronReloadSignalPath() {
-    return path.join(getBeecorkHome(), '.cron-reload');
-}
-export function getWatcherReloadSignalPath() {
-    return path.join(getBeecorkHome(), '.watcher-reload');
-}
-export function getWhatsappSessionPath() {
-    return path.join(getBeecorkHome(), 'whatsapp-session');
-}
-export function ensureBeecorkDirs() {
-    const home = getBeecorkHome();
-    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
-    // Upgrade an existing dir that was created with a looser umask before this fix landed.
-    try {
-        fs.chmodSync(home, 0o700);
-    }
-    catch {
-        /* not fatal if mode change fails */
-    }
-    fs.mkdirSync(getLogsDir(), { recursive: true, mode: 0o700 });
-}
-export function expandHome(p) {
-    if (p.startsWith('~/') || p === '~') {
-        return path.join(os.homedir(), p.slice(1));
-    }
-    return p;
-}

package/dist/util/platform.d.ts

@@ -1,2 +0,0 @@
-export type Platform = 'mac' | 'linux' | 'windows';
-export declare function getPlatform(): Platform;

package/dist/util/platform.js

@@ -1,11 +0,0 @@
-import os from 'node:os';
-export function getPlatform() {
-    const p = os.platform();
-    if (p === 'darwin')
-        return 'mac';
-    if (p === 'linux')
-        return 'linux';
-    if (p === 'win32')
-        return 'windows';
-    throw new Error(`Unsupported platform: ${p}. Beecork supports Mac, Linux, and Windows.`);
-}

package/dist/util/progress.d.ts

@@ -1,34 +0,0 @@
-/**
- * Collects tool use events and sends batched progress updates
- * with escalating intervals and next-update predictions.
- *
- * Schedule: 15s → 30s → 1m → 2m → 3m → 4m → ... (grows by 1m after 2m)
- * Each update tells the user when the next one will come.
- * Works across all channels (Telegram, Discord, WhatsApp, etc.)
- */
-export declare class ProgressTracker {
-    private events;
-    private startTime;
-    private onReport;
-    private timer;
-    private tabName;
-    private reportCount;
-    private readonly intervals;
-    constructor(tabName: string, onReport: (message: string) => void);
-    /** Record a tool use event */
-    record(toolName: string, toolInput: Record<string, unknown>): void;
-    /** Stop the timer (called when task finishes) */
-    stop(): void;
-    /** Get the interval for the current report number */
-    private getInterval;
-    /** Format a duration in ms to a human-readable string */
-    private formatDuration;
-    /** Schedule the next progress report */
-    private scheduleNext;
-    /** Flush pending events as a progress report */
-    private flush;
-    /** Summarize a tool call into a human-readable one-liner */
-    private summarizeTool;
-    private extractPath;
-    private extractCommand;
-}

package/dist/util/progress.js

@@ -1,133 +0,0 @@
-import { logger } from './logger.js';
-/**
- * Collects tool use events and sends batched progress updates
- * with escalating intervals and next-update predictions.
- *
- * Schedule: 15s → 30s → 1m → 2m → 3m → 4m → ... (grows by 1m after 2m)
- * Each update tells the user when the next one will come.
- * Works across all channels (Telegram, Discord, WhatsApp, etc.)
- */
-export class ProgressTracker {
-    events = [];
-    startTime;
-    onReport;
-    timer = null;
-    tabName;
-    reportCount = 0;
-    // Escalating intervals in ms: 15s, 30s, 1m, 2m, then +1m each
-    intervals = [15000, 30000, 60000, 120000];
-    constructor(tabName, onReport) {
-        this.tabName = tabName;
-        this.startTime = Date.now();
-        this.onReport = onReport;
-        this.scheduleNext();
-    }
-    /** Record a tool use event */
-    record(toolName, toolInput) {
-        this.events.push({ tool: toolName, summary: this.summarizeTool(toolName, toolInput) });
-    }
-    /** Stop the timer (called when task finishes) */
-    stop() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-    }
-    /** Get the interval for the current report number */
-    getInterval() {
-        if (this.reportCount < this.intervals.length) {
-            return this.intervals[this.reportCount];
-        }
-        // After the fixed intervals, grow by 1 minute each time (3m, 4m, 5m, ...)
-        const extraMinutes = this.reportCount - this.intervals.length + 3;
-        return extraMinutes * 60000;
-    }
-    /** Format a duration in ms to a human-readable string */
-    formatDuration(ms) {
-        const seconds = Math.round(ms / 1000);
-        if (seconds < 60)
-            return `${seconds}s`;
-        const minutes = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
-    }
-    /** Schedule the next progress report */
-    scheduleNext() {
-        const interval = this.getInterval();
-        this.timer = setTimeout(() => {
-            this.flush();
-            this.reportCount++;
-            this.scheduleNext();
-        }, interval);
-    }
-    /** Flush pending events as a progress report */
-    flush() {
-        if (this.events.length === 0)
-            return;
-        const elapsed = Date.now() - this.startTime;
-        const elapsedStr = this.formatDuration(elapsed);
-        // Build the activity summary
-        const lines = [];
-        for (const event of this.events) {
-            lines.push(`  ${event.summary}`);
-        }
-        this.events = [];
-        // Calculate when the next update will come
-        const nextInterval = this.getInterval();
-        const nextStr = this.formatDuration(nextInterval);
-        const message = [
-            `\uD83D\uDD04 Working on "${this.tabName}" (${elapsedStr} elapsed)`,
-            ...lines,
-            `\n\u23F3 Next update in ${nextStr} or when finished.`,
-        ].join('\n');
-        try {
-            this.onReport(message);
-        }
-        catch (err) {
-            logger.warn('Progress report failed:', err);
-        }
-    }
-    /** Summarize a tool call into a human-readable one-liner */
-    summarizeTool(name, input) {
-        switch (name) {
-            case 'Write':
-            case 'write':
-                return `\uD83D\uDCDD Created ${this.extractPath(input)}`;
-            case 'Edit':
-            case 'edit':
-                return `\uD83D\uDCDD Edited ${this.extractPath(input)}`;
-            case 'Read':
-            case 'read':
-                return `\uD83D\uDC41 Read ${this.extractPath(input)}`;
-            case 'Bash':
-            case 'bash':
-                return `\uD83D\uDD27 Ran: ${this.extractCommand(input)}`;
-            case 'Glob':
-            case 'glob':
-                return `\uD83D\uDD0D Searched for files: ${input.pattern || '...'}`;
-            case 'Grep':
-            case 'grep':
-                return `\uD83D\uDD0D Searched code: ${input.pattern || '...'}`;
-            case 'WebSearch':
-            case 'web_search':
-                return `\uD83C\uDF10 Searched: ${input.query || '...'}`;
-            case 'WebFetch':
-            case 'web_fetch':
-                return `\uD83C\uDF10 Fetched: ${input.url || '...'}`;
-            default:
-                return `\u2699\uFE0F ${name}`;
-        }
-    }
-    extractPath(input) {
-        const p = (input.file_path || input.path || input.filePath || '');
-        if (p.includes('/'))
-            return p.split('/').pop() || p;
-        if (p.includes('\\'))
-            return p.split('\\').pop() || p;
-        return p || '...';
-    }
-    extractCommand(input) {
-        const cmd = (input.command || input.cmd || '');
-        return cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd || '...';
-    }
-}

package/dist/util/rate-limiter.d.ts

@@ -1,14 +0,0 @@
-export declare class RateLimiter {
-    private globalLimit;
-    private perKeyLimit;
-    private windowMs;
-    private global;
-    private perKey;
-    constructor(globalLimit?: number, perKeyLimit?: number, windowMs?: number);
-    /** Returns true if the request is allowed */
-    check(key: string): boolean;
-}
-/** Shared singleton rate limiter for inbound messages */
-export declare const inboundLimiter: RateLimiter;
-/** Rate limiter for group responses */
-export declare const groupLimiter: RateLimiter;

package/dist/util/rate-limiter.js

@@ -1,50 +0,0 @@
-import { logger } from './logger.js';
-export class RateLimiter {
-    globalLimit;
-    perKeyLimit;
-    windowMs;
-    global = { count: 0, resetAt: Date.now() + 60000 };
-    perKey = new Map();
-    constructor(globalLimit = 20, perKeyLimit = 10, windowMs = 60000) {
-        this.globalLimit = globalLimit;
-        this.perKeyLimit = perKeyLimit;
-        this.windowMs = windowMs;
-    }
-    /** Returns true if the request is allowed */
-    check(key) {
-        const now = Date.now();
-        // Reset global window
-        if (now > this.global.resetAt) {
-            this.global = { count: 0, resetAt: now + this.windowMs };
-        }
-        if (this.global.count >= this.globalLimit) {
-            logger.warn(`Rate limit: global limit reached (${this.globalLimit}/min)`);
-            return false;
-        }
-        // Bound the per-key map so a daemon that has seen many one-off keys
-        // (e.g. thousands of Telegram groups over months) doesn't leak memory.
-        if (this.perKey.size > 1000) {
-            for (const [k, w] of this.perKey) {
-                if (now > w.resetAt)
-                    this.perKey.delete(k);
-            }
-        }
-        // Reset per-key window
-        let keyWindow = this.perKey.get(key);
-        if (!keyWindow || now > keyWindow.resetAt) {
-            keyWindow = { count: 0, resetAt: now + this.windowMs };
-            this.perKey.set(key, keyWindow);
-        }
-        if (keyWindow.count >= this.perKeyLimit) {
-            logger.warn(`Rate limit: channel ${key} limit reached (${this.perKeyLimit}/min)`);
-            return false;
-        }
-        this.global.count++;
-        keyWindow.count++;
-        return true;
-    }
-}
-/** Shared singleton rate limiter for inbound messages */
-export const inboundLimiter = new RateLimiter(60, 30);
-/** Rate limiter for group responses */
-export const groupLimiter = new RateLimiter(10, 3, 60000); // 10 global, 3 per group per minute

package/dist/util/retry.d.ts

@@ -1,2 +0,0 @@
-/** Retry a function with exponential backoff */
-export declare function retryWithBackoff<T>(fn: () => Promise<T>, delays?: number[], label?: string): Promise<T>;

package/dist/util/retry.js

@@ -1,18 +0,0 @@
-import { logger } from './logger.js';
-/** Retry a function with exponential backoff */
-export async function retryWithBackoff(fn, delays = [1000, 5000, 15000], label = 'operation') {
-    let lastError;
-    for (let attempt = 0; attempt <= delays.length; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-            if (attempt < delays.length) {
-                logger.warn(`${label} failed (attempt ${attempt + 1}/${delays.length + 1}), retrying in ${delays[attempt]}ms: ${lastError.message}`);
-                await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
-            }
-        }
-    }
-    throw lastError ?? new Error(`${label} failed after ${delays.length + 1} attempts`);
-}

package/dist/util/text.d.ts

@@ -1,32 +0,0 @@
-import type { MediaAttachment } from '../types.js';
-/**
- * Shared message-size limits. Single source of truth so caps don't drift
- * between channels, MCP, and dashboard.
- */
-export declare const MESSAGE_LIMITS: {
-    /** Per-chunk send size (Telegram = 4096; other channels chunk to this too). */
-    readonly CHUNK: 4096;
-    /** HTTP request body cap (webhook + dashboard endpoints). */
-    readonly HTTP_BODY: number;
-    /** Webhook channel single-message payload. */
-    readonly WEBHOOK_PROMPT: 100000;
-    /** MCP tool content/message field. Tight because it goes through Claude's tool-result token budget. */
-    readonly MCP_CONTENT: 10240;
-};
-/** Split long text into chunks that fit within a message limit */
-export declare function chunkText(text: string, maxLength?: number): string[];
-/** Format an ISO date as a human-readable relative time */
-export declare function timeAgo(isoDate: string): string;
-/** Parse a "/tab <name> <prompt>" message into tabName + prompt */
-export declare function parseTabMessage(text: string): {
-    tabName: string;
-    prompt: string;
-};
-/**
- * Build the channel-side message text with an optional [tabName] prefix.
- * Used by all three channels' sendResponse paths so the prefix format is
- * consistent and the gate logic (skip "default", skip empty) lives in one place.
- */
-export declare function formatTabbedResponse(text: string, tabName?: string): string;
-/** Build prompt text from media attachments */
-export declare function buildMediaPrompt(media: MediaAttachment[], textPrompt: string): string;

package/dist/util/text.js

@@ -1,101 +0,0 @@
-/**
- * Shared message-size limits. Single source of truth so caps don't drift
- * between channels, MCP, and dashboard.
- */
-export const MESSAGE_LIMITS = {
-    /** Per-chunk send size (Telegram = 4096; other channels chunk to this too). */
-    CHUNK: 4096,
-    /** HTTP request body cap (webhook + dashboard endpoints). */
-    HTTP_BODY: 1024 * 1024, // 1 MB
-    /** Webhook channel single-message payload. */
-    WEBHOOK_PROMPT: 100_000, // 100 KB
-    /** MCP tool content/message field. Tight because it goes through Claude's tool-result token budget. */
-    MCP_CONTENT: 10_240, // 10 KB
-};
-const DEFAULT_MAX_LENGTH = MESSAGE_LIMITS.CHUNK;
-/** Split long text into chunks that fit within a message limit */
-export function chunkText(text, maxLength = DEFAULT_MAX_LENGTH) {
-    if (text.length <= maxLength)
-        return [text];
-    const chunks = [];
-    let remaining = text;
-    while (remaining.length > 0) {
-        if (remaining.length <= maxLength) {
-            chunks.push(remaining);
-            break;
-        }
-        // Try to break at a newline
-        let breakPoint = remaining.lastIndexOf('\n', maxLength);
-        if (breakPoint <= 0 || breakPoint < maxLength * 0.5) {
-            // Try to break at a space
-            breakPoint = remaining.lastIndexOf(' ', maxLength);
-        }
-        if (breakPoint <= 0 || breakPoint < maxLength * 0.5) {
-            // Hard break
-            breakPoint = maxLength;
-        }
-        chunks.push(remaining.slice(0, breakPoint));
-        remaining = remaining.slice(breakPoint).trimStart();
-    }
-    return chunks;
-}
-/** Format an ISO date as a human-readable relative time */
-export function timeAgo(isoDate) {
-    const diff = Date.now() - new Date(isoDate).getTime();
-    const mins = Math.floor(diff / 60000);
-    if (mins < 1)
-        return 'just now';
-    if (mins < 60)
-        return `${mins}m ago`;
-    const hours = Math.floor(mins / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
-}
-/** Parse a "/tab <name> <prompt>" message into tabName + prompt */
-export function parseTabMessage(text) {
-    if (text.startsWith('/tab ')) {
-        const rest = text.slice(5);
-        const spaceIdx = rest.indexOf(' ');
-        if (spaceIdx === -1)
-            return { tabName: rest, prompt: '' };
-        return { tabName: rest.slice(0, spaceIdx), prompt: rest.slice(spaceIdx + 1).trim() };
-    }
-    return { tabName: 'default', prompt: text };
-}
-/**
- * Build the channel-side message text with an optional [tabName] prefix.
- * Used by all three channels' sendResponse paths so the prefix format is
- * consistent and the gate logic (skip "default", skip empty) lives in one place.
- */
-export function formatTabbedResponse(text, tabName) {
-    if (!tabName || tabName === 'default')
-        return text;
-    return `[${tabName}] ${text}`;
-}
-/** Build prompt text from media attachments */
-export function buildMediaPrompt(media, textPrompt) {
-    if (media.length === 0)
-        return textPrompt;
-    const descriptions = media.map((m) => {
-        if (m.type === 'voice' && m.caption?.startsWith('[Transcribed'))
-            return m.caption;
-        switch (m.type) {
-            case 'image':
-                return `User sent an image: ${m.filePath}`;
-            case 'voice':
-                return `User sent a voice message: ${m.filePath}`;
-            case 'audio':
-                return `User sent an audio file: ${m.filePath}${m.fileName ? ` (${m.fileName})` : ''}`;
-            case 'video':
-                return `User sent a video: ${m.filePath}`;
-            case 'document':
-                return `User sent a file: ${m.filePath}${m.fileName ? ` (${m.fileName})` : ''}`;
-            default:
-                return `User sent a file: ${m.filePath}`;
-        }
-    });
-    const mediaText = descriptions.join('\n');
-    return textPrompt ? `${mediaText}\n\n${textPrompt}` : mediaText;
-}

package/dist/version.d.ts

@@ -1 +0,0 @@
-export declare const VERSION: string;

package/dist/version.js

@@ -1,4 +0,0 @@
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const pkg = require('../package.json');
-export const VERSION = pkg.version;

package/dist/voice/index.d.ts

@@ -1,17 +0,0 @@
-export { createSTTProvider, type STTProvider } from './stt.js';
-export { createTTSProvider, type TTSProvider } from './tts.js';
-import { type STTProvider } from './stt.js';
-import { type TTSProvider } from './tts.js';
-import type { VoiceConfig } from '../types.js';
-export declare function initVoiceProviders(voice?: VoiceConfig): {
-    stt: STTProvider | null;
-    tts: TTSProvider | null;
-};
-export declare function transcribeVoiceMessages(media: Array<{
-    type: string;
-    filePath?: string;
-    caption?: string;
-}>, sttProvider: {
-    transcribe(path: string): Promise<string>;
-    warmup?(): void;
-}, channelId: string, warmedUp: boolean): Promise<boolean>;

package/dist/voice/index.js

@@ -1,42 +0,0 @@
-export { createSTTProvider } from './stt.js';
-export { createTTSProvider } from './tts.js';
-import { createSTTProvider } from './stt.js';
-import { createTTSProvider } from './tts.js';
-import { logger } from '../util/logger.js';
-export function initVoiceProviders(voice) {
-    let stt = null;
-    let tts = null;
-    if (voice?.sttProvider && voice.sttProvider !== 'none') {
-        stt = createSTTProvider({ provider: voice.sttProvider, apiKey: voice.sttApiKey });
-    }
-    if (voice?.ttsProvider && voice.ttsProvider !== 'none') {
-        tts = createTTSProvider({
-            provider: voice.ttsProvider,
-            apiKey: voice.ttsApiKey,
-            voice: voice.ttsVoice,
-        });
-    }
-    return { stt, tts };
-}
-export async function transcribeVoiceMessages(media, sttProvider, channelId, warmedUp) {
-    if (!sttProvider)
-        return warmedUp;
-    if (!warmedUp) {
-        sttProvider.warmup?.();
-        warmedUp = true;
-    }
-    for (const m of media) {
-        if (m.type === 'voice' && m.filePath) {
-            const start = Date.now();
-            try {
-                const transcription = await sttProvider.transcribe(m.filePath);
-                m.caption = `[Transcribed from voice message]: ${transcription}`;
-                logger.info(`[${channelId}] Voice transcription: ${Date.now() - start}ms`);
-            }
-            catch (err) {
-                logger.warn('Voice transcription failed, passing file path instead:', err);
-            }
-        }
-    }
-    return warmedUp;
-}