beecork 1.7.1 → 2.0.0

package/dist/media/generators/elevenlabs-sfx.js

@@ -1,33 +0,0 @@
-import { saveMedia } from '../store.js';
-export class ElevenLabsSfxGenerator {
-    apiKey;
-    id = 'elevenlabs-sfx';
-    name = 'ElevenLabs Sound Effects';
-    supportedTypes = ['audio'];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'audio')
-            throw new Error('ElevenLabs SFX only supports audio generation');
-        const response = await fetch('https://api.elevenlabs.io/v1/sound-generation', {
-            method: 'POST',
-            headers: {
-                'xi-api-key': this.apiKey,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                text: prompt.slice(0, 500),
-                duration_seconds: options?.duration,
-            }),
-            signal: AbortSignal.timeout(60000),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`ElevenLabs SFX error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const buffer = Buffer.from(await response.arrayBuffer());
-        const filePath = saveMedia(buffer, 'mp3', 'generated-sfx.mp3');
-        return { filePath, mimeType: 'audio/mpeg' };
-    }
-}

package/dist/media/generators/kling.d.ts

@@ -1,9 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class KlingGenerator implements MediaGenerator {
-    private apiKey;
-    readonly id = "kling";
-    readonly name = "Kling AI";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/kling.js

@@ -1,47 +0,0 @@
-import { saveMedia } from '../store.js';
-import { pollForCompletion } from './poll-util.js';
-export class KlingGenerator {
-    apiKey;
-    id = 'kling';
-    name = 'Kling AI';
-    supportedTypes = ['video'];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'video')
-            throw new Error('Kling only supports video generation');
-        const response = await fetch('https://api.klingai.com/v1/videos/text2video', {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                prompt: prompt.slice(0, 2500),
-                duration: options?.duration || 5,
-                model_name: 'kling-v1',
-            }),
-            signal: AbortSignal.timeout(30000),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Kling error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const { data } = (await response.json());
-        // Poll for completion
-        const headers = { Authorization: `Bearer ${this.apiKey}` };
-        const videoUrl = await pollForCompletion({
-            statusUrl: `https://api.klingai.com/v1/videos/text2video/${data.task_id}`,
-            headers,
-            isComplete: (d) => d.data.task_status === 'succeed' && !!d.data.task_result?.videos[0],
-            isFailed: (d) => (d.data.task_status === 'failed' ? 'generation failed' : null),
-            getResultUrl: (d) => d.data.task_result.videos[0].url,
-            label: 'Kling',
-        });
-        const videoResp = await fetch(videoUrl, { signal: AbortSignal.timeout(60000) });
-        const buffer = Buffer.from(await videoResp.arrayBuffer());
-        const filePath = saveMedia(buffer, 'mp4', 'generated-video.mp4');
-        return { filePath, mimeType: 'video/mp4' };
-    }
-}

package/dist/media/generators/lyria.d.ts

@@ -1,10 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class LyriaGenerator implements MediaGenerator {
-    private apiKey;
-    private model;
-    readonly id = "lyria";
-    readonly name = "Google Lyria";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string, model?: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/lyria.js

@@ -1,41 +0,0 @@
-import { saveMedia } from '../store.js';
-export class LyriaGenerator {
-    apiKey;
-    model;
-    id = 'lyria';
-    name = 'Google Lyria';
-    supportedTypes = ['music'];
-    constructor(apiKey, model = 'lyria-3-clip') {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'music')
-            throw new Error('Lyria only supports music generation');
-        const useProModel = (options?.duration && options.duration > 30) || this.model.includes('pro');
-        const modelId = useProModel ? 'lyria-3-pro' : 'lyria-3-clip';
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${this.apiKey}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                contents: [{ parts: [{ text: prompt.slice(0, 2000) }] }],
-                generationConfig: {
-                    responseModalities: ['AUDIO'],
-                },
-            }),
-            signal: AbortSignal.timeout(300000), // 5 min for full songs
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Lyria error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const data = (await response.json());
-        const audioPart = data.candidates?.[0]?.content?.parts?.find((p) => p.inlineData);
-        if (!audioPart?.inlineData?.data) {
-            throw new Error('Lyria returned no audio data');
-        }
-        const buffer = Buffer.from(audioPart.inlineData.data, 'base64');
-        const filePath = saveMedia(buffer, 'mp3', 'generated-music.mp3');
-        return { filePath, mimeType: 'audio/mpeg' };
-    }
-}

package/dist/media/generators/nano-banana.d.ts

@@ -1,10 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class NanoBananaGenerator implements MediaGenerator {
-    private apiKey;
-    private model;
-    readonly id = "nano-banana";
-    readonly name = "Google Nano Banana";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string, model?: string);
-    generate(type: MediaType, prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/nano-banana.js

@@ -1,45 +0,0 @@
-import { saveMedia } from '../store.js';
-export class NanoBananaGenerator {
-    apiKey;
-    model;
-    id = 'nano-banana';
-    name = 'Google Nano Banana';
-    supportedTypes = ['image'];
-    constructor(apiKey, model = 'gemini-2.5-flash-image') {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async generate(type, prompt, _options) {
-        if (type !== 'image')
-            throw new Error('Nano Banana only supports image generation');
-        // Gemini image generation API
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                contents: [{ parts: [{ text: prompt.slice(0, 2000) }] }],
-                generationConfig: {
-                    responseModalities: ['IMAGE'],
-                    imageGenerationConfig: {
-                        numberOfImages: 1,
-                    },
-                },
-            }),
-            signal: AbortSignal.timeout(120000),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Nano Banana error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const data = (await response.json());
-        const imagePart = data.candidates?.[0]?.content?.parts?.find((p) => p.inlineData);
-        if (!imagePart?.inlineData?.data) {
-            throw new Error('Nano Banana returned no image data');
-        }
-        const buffer = Buffer.from(imagePart.inlineData.data, 'base64');
-        const mimeType = imagePart.inlineData.mimeType || 'image/png';
-        const ext = mimeType.includes('jpeg') ? 'jpg' : 'png';
-        const filePath = saveMedia(buffer, ext, `generated-image.${ext}`);
-        return { filePath, mimeType };
-    }
-}

package/dist/media/generators/poll-util.d.ts

@@ -1,12 +0,0 @@
-interface PollOptions<T = unknown> {
-    statusUrl: string;
-    headers: Record<string, string>;
-    isComplete: (data: T) => boolean;
-    isFailed: (data: T) => string | null;
-    getResultUrl: (data: T) => string;
-    interval?: number;
-    maxAttempts?: number;
-    label?: string;
-}
-export declare function pollForCompletion<T = unknown>(opts: PollOptions<T>): Promise<string>;
-export {};

package/dist/media/generators/poll-util.js

@@ -1,22 +0,0 @@
-import { logger } from '../../util/logger.js';
-export async function pollForCompletion(opts) {
-    const { statusUrl, headers, isComplete, isFailed, getResultUrl, interval = 5000, maxAttempts = 60, label = 'API', } = opts;
-    for (let i = 0; i < maxAttempts; i++) {
-        await new Promise((r) => setTimeout(r, interval));
-        const resp = await fetch(statusUrl, { headers, signal: AbortSignal.timeout(10000) });
-        if (!resp.ok) {
-            logger.warn(`[${label}] Poll failed: ${resp.status}`);
-            if (resp.status >= 400 && resp.status < 500) {
-                throw new Error(`${label} API error: ${resp.status}`);
-            }
-            continue;
-        }
-        const data = (await resp.json());
-        const failMsg = isFailed(data);
-        if (failMsg)
-            throw new Error(`${label} generation failed: ${failMsg}`);
-        if (isComplete(data))
-            return getResultUrl(data);
-    }
-    throw new Error(`${label} generation timed out after ${(maxAttempts * interval) / 1000}s`);
-}

package/dist/media/generators/recraft.d.ts

@@ -1,9 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class RecraftGenerator implements MediaGenerator {
-    private apiKey;
-    readonly id = "recraft";
-    readonly name = "Recraft (Images + Vectors)";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/recraft.js

@@ -1,52 +0,0 @@
-import { saveMedia } from '../store.js';
-export class RecraftGenerator {
-    apiKey;
-    id = 'recraft';
-    name = 'Recraft (Images + Vectors)';
-    supportedTypes = ['image']; // SVG vectors are still "images"
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'image')
-            throw new Error('Recraft only supports image/vector generation');
-        const isVector = options?.format === 'svg' || options?.style === 'vector';
-        const endpoint = isVector
-            ? 'https://external.api.recraft.ai/v1/images/generations'
-            : 'https://external.api.recraft.ai/v1/images/generations';
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                prompt: prompt.slice(0, 2000),
-                model: isVector ? 'recraftv4' : 'recraftv4',
-                response_format: isVector ? 'url' : 'b64_json',
-                style: isVector ? 'vector_illustration' : options?.style || 'realistic_image',
-                size: options?.width && options?.height ? `${options.width}x${options.height}` : '1024x1024',
-            }),
-            signal: AbortSignal.timeout(120000),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Recraft error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const data = (await response.json());
-        const image = data.data?.[0];
-        if (isVector && image?.url) {
-            // Download SVG from URL
-            const svgResp = await fetch(image.url, { signal: AbortSignal.timeout(30000) });
-            const svgBuffer = Buffer.from(await svgResp.arrayBuffer());
-            const filePath = saveMedia(svgBuffer, 'svg', 'generated-vector.svg');
-            return { filePath, mimeType: 'image/svg+xml' };
-        }
-        else if (image?.b64_json) {
-            const buffer = Buffer.from(image.b64_json, 'base64');
-            const filePath = saveMedia(buffer, 'png', 'generated-image.png');
-            return { filePath, mimeType: 'image/png' };
-        }
-        throw new Error('Recraft returned no image data');
-    }
-}

package/dist/media/generators/runway.d.ts

@@ -1,9 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class RunwayGenerator implements MediaGenerator {
-    private apiKey;
-    readonly id = "runway";
-    readonly name = "Runway Gen-3";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/runway.js

@@ -1,49 +0,0 @@
-import { saveMedia } from '../store.js';
-import { pollForCompletion } from './poll-util.js';
-export class RunwayGenerator {
-    apiKey;
-    id = 'runway';
-    name = 'Runway Gen-3';
-    supportedTypes = ['video'];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'video')
-            throw new Error('Runway only supports video generation');
-        // Start generation
-        const startResponse = await fetch('https://api.runwayml.com/v1/image_to_video', {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                'X-Runway-Version': '2024-11-06',
-            },
-            body: JSON.stringify({
-                model: 'gen3a_turbo',
-                promptText: prompt.slice(0, 2000),
-                duration: options?.duration || 5,
-            }),
-            signal: AbortSignal.timeout(30000),
-        });
-        if (!startResponse.ok) {
-            const err = await startResponse.text();
-            throw new Error(`Runway error ${startResponse.status}: ${err.slice(0, 200)}`);
-        }
-        const { id: taskId } = (await startResponse.json());
-        // Poll for completion (max 5 minutes)
-        const headers = { Authorization: `Bearer ${this.apiKey}`, 'X-Runway-Version': '2024-11-06' };
-        const videoUrl = await pollForCompletion({
-            statusUrl: `https://api.runwayml.com/v1/tasks/${taskId}`,
-            headers,
-            isComplete: (data) => data.status === 'SUCCEEDED' && !!data.output?.[0],
-            isFailed: (data) => (data.status === 'FAILED' ? 'generation failed' : null),
-            getResultUrl: (data) => data.output[0],
-            label: 'Runway',
-        });
-        const videoResponse = await fetch(videoUrl, { signal: AbortSignal.timeout(60000) });
-        const buffer = Buffer.from(await videoResponse.arrayBuffer());
-        const filePath = saveMedia(buffer, 'mp4', 'generated-video.mp4');
-        return { filePath, mimeType: 'video/mp4', durationMs: (options?.duration || 5) * 1000 };
-    }
-}

package/dist/media/generators/stable-diffusion.d.ts

@@ -1,9 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class StableDiffusionGenerator implements MediaGenerator {
-    private apiKey;
-    readonly id = "stable-diffusion";
-    readonly name = "Stable Diffusion (Stability AI)";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/stable-diffusion.js

@@ -1,35 +0,0 @@
-import { saveMedia } from '../store.js';
-export class StableDiffusionGenerator {
-    apiKey;
-    id = 'stable-diffusion';
-    name = 'Stable Diffusion (Stability AI)';
-    supportedTypes = ['image'];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'image')
-            throw new Error('Stable Diffusion only supports image generation');
-        const formData = new FormData();
-        formData.append('prompt', prompt.slice(0, 10000));
-        if (options?.style)
-            formData.append('style_preset', options.style);
-        formData.append('output_format', 'png');
-        const response = await fetch('https://api.stability.ai/v2beta/stable-image/generate/core', {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                Accept: 'image/*',
-            },
-            body: formData,
-            signal: AbortSignal.timeout(120000),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Stability AI error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const buffer = Buffer.from(await response.arrayBuffer());
-        const filePath = saveMedia(buffer, 'png', 'generated-image.png');
-        return { filePath, mimeType: 'image/png' };
-    }
-}

package/dist/media/generators/veo.d.ts

@@ -1,9 +0,0 @@
-import type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from '../types.js';
-export declare class VeoGenerator implements MediaGenerator {
-    private apiKey;
-    readonly id = "veo";
-    readonly name = "Google Veo";
-    readonly supportedTypes: MediaType[];
-    constructor(apiKey: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}

package/dist/media/generators/veo.js

@@ -1,32 +0,0 @@
-import { saveMedia } from '../store.js';
-export class VeoGenerator {
-    apiKey;
-    id = 'veo';
-    name = 'Google Veo';
-    supportedTypes = ['video'];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async generate(type, prompt, options) {
-        if (type !== 'video')
-            throw new Error('Veo only supports video generation');
-        // Use Gemini API for Veo access
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/veo-2.0-generate-001:predict?key=${this.apiKey}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                instances: [{ prompt: prompt.slice(0, 2000) }],
-                parameters: { sampleCount: 1, durationSeconds: options?.duration || 5 },
-            }),
-            signal: AbortSignal.timeout(300000), // 5 min timeout for video
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Veo error ${response.status}: ${err.slice(0, 200)}`);
-        }
-        const data = (await response.json());
-        const buffer = Buffer.from(data.predictions[0].bytesBase64Encoded, 'base64');
-        const filePath = saveMedia(buffer, 'mp4', 'generated-video.mp4');
-        return { filePath, mimeType: 'video/mp4', durationMs: (options?.duration || 5) * 1000 };
-    }
-}

package/dist/media/index.d.ts

@@ -1,6 +0,0 @@
-export type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from './types.js';
-export { createMediaGenerator } from './factory.js';
-export { saveMedia, cleanupMedia, ensureMediaDir, isOversized } from './store.js';
-import type { MediaGenerator } from './types.js';
-import type { MediaGeneratorConfig } from '../types.js';
-export declare function initMediaGenerators(configs?: MediaGeneratorConfig[]): MediaGenerator[];

package/dist/media/index.js

@@ -1,8 +0,0 @@
-export { createMediaGenerator } from './factory.js';
-export { saveMedia, cleanupMedia, ensureMediaDir, isOversized } from './store.js';
-import { createMediaGenerator } from './factory.js';
-export function initMediaGenerators(configs) {
-    if (!configs || configs.length === 0)
-        return [];
-    return configs.map((c) => createMediaGenerator(c)).filter((g) => g !== null);
-}

package/dist/media/loader.d.ts

@@ -1,8 +0,0 @@
-import type { MediaGenerator } from './types.js';
-/**
- * Discover and load community media generator packages from node_modules.
- * Convention: packages named `beecork-media-<name>` must export a default
- * class implementing the MediaGenerator interface.
- */
-export declare function loadCommunityGenerators(apiKeys?: Record<string, string>): Promise<MediaGenerator[]>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/media/loader.js

@@ -1,46 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../util/logger.js';
-const MEDIA_PREFIX = 'beecork-media-';
-/**
- * Discover and load community media generator packages from node_modules.
- * Convention: packages named `beecork-media-<name>` must export a default
- * class implementing the MediaGenerator interface.
- */
-export async function loadCommunityGenerators(apiKeys) {
-    const generators = [];
-    const searchPaths = [path.join(process.cwd(), 'node_modules')];
-    for (const searchPath of searchPaths) {
-        if (!fs.existsSync(searchPath))
-            continue;
-        try {
-            for (const dir of fs.readdirSync(searchPath)) {
-                if (!dir.startsWith(MEDIA_PREFIX))
-                    continue;
-                try {
-                    const pkgPath = path.join(searchPath, dir);
-                    const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'), 'utf-8'));
-                    const entryPath = path.join(pkgPath, pkgJson.main || 'index.js');
-                    if (!fs.existsSync(entryPath))
-                        continue;
-                    const module = await import(entryPath);
-                    const GeneratorClass = module.default || module[Object.keys(module)[0]];
-                    if (!GeneratorClass || typeof GeneratorClass !== 'function')
-                        continue;
-                    const name = dir.slice(MEDIA_PREFIX.length);
-                    const instance = new GeneratorClass(apiKeys?.[name]);
-                    if (!instance.id || !instance.name || typeof instance.generate !== 'function')
-                        continue;
-                    generators.push(instance);
-                    logger.info(`Community media generator loaded: ${instance.name} (${instance.id})`);
-                }
-                catch (err) {
-                    logger.warn(`Failed to load community generator ${dir}:`, err);
-                }
-            }
-        }
-        catch { }
-    }
-    return generators;
-}
-//# sourceMappingURL=loader.js.map

package/dist/media/store.d.ts

@@ -1,17 +0,0 @@
-/** Ensure media directory exists */
-export declare function ensureMediaDir(): string;
-/** Save a buffer to the media directory with a unique filename */
-export declare function saveMedia(buffer: Buffer, extension: string, originalName?: string): string;
-/** Check if a file exceeds the size limit */
-export declare function isOversized(sizeBytes: number, maxSizeMb?: number): boolean;
-/** Clean up expired media files */
-export declare function cleanupMedia(ttlMs?: number): number;
-/** Get the media directory path */
-export declare function getMediaDir(): string;
-/**
- * Resolve a file path and confirm it lives inside the beecork media directory.
- * Throws otherwise. Used at trust boundaries (MCP tools, voice transcription)
- * where a caller could otherwise hand us an arbitrary path to read or upload.
- * Returns the resolved (absolute) path on success.
- */
-export declare function assertInsideMediaDir(filePath: string): string;

package/dist/media/store.js

@@ -1,69 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { getBeecorkHome } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-const MEDIA_DIR = path.join(getBeecorkHome(), 'media');
-const DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 minutes
-const DEFAULT_MAX_SIZE_MB = 25;
-/** Ensure media directory exists */
-export function ensureMediaDir() {
-    fs.mkdirSync(MEDIA_DIR, { recursive: true });
-    return MEDIA_DIR;
-}
-/** Save a buffer to the media directory with a unique filename */
-export function saveMedia(buffer, extension, originalName) {
-    ensureMediaDir();
-    const timestamp = Date.now();
-    const safeName = originalName
-        ? originalName.replace(/[\/\\]/g, '_').replace(/\.\./g, '_')
-        : undefined;
-    const name = safeName ? `${timestamp}-${safeName}` : `${timestamp}.${extension}`;
-    const filePath = path.join(MEDIA_DIR, name);
-    fs.writeFileSync(filePath, buffer);
-    return filePath;
-}
-/** Check if a file exceeds the size limit */
-export function isOversized(sizeBytes, maxSizeMb = DEFAULT_MAX_SIZE_MB) {
-    return sizeBytes > maxSizeMb * 1024 * 1024;
-}
-/** Clean up expired media files */
-export function cleanupMedia(ttlMs = DEFAULT_TTL_MS) {
-    if (!fs.existsSync(MEDIA_DIR))
-        return 0;
-    const now = Date.now();
-    let cleaned = 0;
-    for (const file of fs.readdirSync(MEDIA_DIR)) {
-        const filePath = path.join(MEDIA_DIR, file);
-        try {
-            const stat = fs.statSync(filePath);
-            if (now - stat.mtimeMs > ttlMs) {
-                fs.unlinkSync(filePath);
-                cleaned++;
-            }
-        }
-        catch {
-            /* file may have been deleted by another process */
-        }
-    }
-    if (cleaned > 0)
-        logger.info(`Media cleanup: removed ${cleaned} expired files`);
-    return cleaned;
-}
-/** Get the media directory path */
-export function getMediaDir() {
-    return MEDIA_DIR;
-}
-/**
- * Resolve a file path and confirm it lives inside the beecork media directory.
- * Throws otherwise. Used at trust boundaries (MCP tools, voice transcription)
- * where a caller could otherwise hand us an arbitrary path to read or upload.
- * Returns the resolved (absolute) path on success.
- */
-export function assertInsideMediaDir(filePath) {
-    const resolved = path.resolve(filePath);
-    const root = path.resolve(MEDIA_DIR) + path.sep;
-    if (!resolved.startsWith(root)) {
-        throw new Error(`filePath must be inside the beecork media directory (${MEDIA_DIR})`);
-    }
-    return resolved;
-}