beecork 1.4.11 → 1.6.0

package/dist/mcp/tool-definitions.js

@@ -0,0 +1,412 @@
+// MCP tool definitions for the Beecork MCP server.
+// One array, one place to maintain the public tool surface. Handler logic
+// lives in `./handlers.ts`; the server file (`./server.ts`) glues them.
+export const TOOL_DEFINITIONS = [
+    {
+        name: 'beecork_remember',
+        description: "Store a fact in Beecork's long-term memory. Use this for preferences, decisions, server addresses, outcomes, or anything the user might want recalled in future sessions.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The fact or information to remember' },
+                scope: {
+                    type: 'string',
+                    enum: ['global', 'project', 'tab', 'auto'],
+                    description: 'Where to store: global (about the user), project (about this folder), tab (about this conversation), or auto (Claude decides)',
+                },
+                category: {
+                    type: 'string',
+                    description: 'For global scope: people, preferences, routines, or general',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'beecork_task_create',
+        description: 'Schedule a task that will run automatically. The task sends a message to a Beecork tab at the scheduled time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the task' },
+                scheduleType: {
+                    type: 'string',
+                    enum: ['at', 'every', 'cron'],
+                    description: '"at" = one-time ISO datetime, "every" = interval like "30m"/"2h"/"1d", "cron" = cron expression like "0 9 * * 1"',
+                },
+                schedule: {
+                    type: 'string',
+                    description: 'The schedule value (ISO datetime, interval, or cron expression)',
+                },
+                message: { type: 'string', description: 'The prompt/message to send when the task fires' },
+                tabName: {
+                    type: 'string',
+                    description: 'Which tab to send the message to (default: "default")',
+                },
+            },
+            required: ['name', 'scheduleType', 'schedule', 'message'],
+        },
+    },
+    {
+        name: 'beecork_task_list',
+        description: 'List all scheduled tasks.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_task_delete',
+        description: 'Delete a scheduled task by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'The ID of the task to delete' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_cron_create',
+        description: '[DEPRECATED — use beecork_task_create] Schedule a task that will run automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the job' },
+                scheduleType: { type: 'string', enum: ['at', 'every', 'cron'] },
+                schedule: { type: 'string' },
+                message: { type: 'string' },
+                tabName: { type: 'string' },
+            },
+            required: ['name', 'scheduleType', 'schedule', 'message'],
+        },
+    },
+    {
+        name: 'beecork_cron_list',
+        description: '[DEPRECATED — use beecork_task_list] List all scheduled tasks.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_cron_delete',
+        description: '[DEPRECATED — use beecork_task_delete] Delete a scheduled task by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_watch_create',
+        description: 'Create a watcher that periodically runs a check command and triggers an action when a condition is met.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the watcher' },
+                description: { type: 'string', description: 'What to watch (natural language)' },
+                checkCommand: { type: 'string', description: 'Shell command to run for checking' },
+                condition: {
+                    type: 'string',
+                    description: 'When to trigger: "contains X", "not contains X", "> N", "< N", "any", "error"',
+                },
+                action: {
+                    type: 'string',
+                    enum: ['notify', 'fix', 'delegate'],
+                    description: 'What to do when triggered (default: notify)',
+                },
+                actionDetails: {
+                    type: 'string',
+                    description: 'For fix: command to run. For delegate: tab name + message.',
+                },
+                schedule: {
+                    type: 'string',
+                    description: 'How often to check: cron expression or interval like "5m", "1h"',
+                },
+            },
+            required: ['name', 'checkCommand', 'condition', 'schedule'],
+        },
+    },
+    {
+        name: 'beecork_watch_list',
+        description: 'List all watchers.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_watch_delete',
+        description: 'Delete a watcher by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_tab_create',
+        description: 'Create a new Beecork tab (an isolated Claude session with its own working directory and history).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Tab name (alphanumeric + hyphens, max 32 chars). Cannot be "default".',
+                },
+                workingDir: {
+                    type: 'string',
+                    description: "Absolute path or ~/path for the tab's working directory",
+                },
+                template: {
+                    type: 'string',
+                    description: 'Name of a tab template from config (sets workingDir + systemPrompt)',
+                },
+                systemPrompt: { type: 'string', description: 'Tab-specific system prompt for Claude' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'beecork_tab_list',
+        description: 'List all Beecork tabs and their status.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_send_message',
+        description: "Send a message to another Beecork tab. The message will be processed asynchronously by that tab's Claude subprocess.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tabName: { type: 'string', description: 'Which tab to send to' },
+                message: { type: 'string', description: 'The message text' },
+            },
+            required: ['tabName', 'message'],
+        },
+    },
+    {
+        name: 'beecork_recall',
+        description: "Search Beecork's memory and knowledge files for facts matching a query.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query (matches content substrings)' },
+                limit: { type: 'number', description: 'Max results (default 10, max 50)' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'beecork_notify',
+        description: 'Send a notification to the user via their configured channels (Telegram, Discord, etc.).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                message: { type: 'string', description: 'The notification text' },
+                urgent: { type: 'boolean', description: 'Prepend a 🚨 prefix' },
+            },
+            required: ['message'],
+        },
+    },
+    {
+        name: 'beecork_status',
+        description: 'Get a summary of Beecork state: tab/task/watcher/memory counts.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_send_media',
+        description: "Send a generated or local media file (image/video/audio) through the user's channels.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the media file' },
+                caption: { type: 'string', description: 'Optional caption' },
+                tabName: {
+                    type: 'string',
+                    description: 'Tab to attribute the send to (default: "default")',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'beecork_channels',
+        description: 'List configured channels and their capabilities.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_cost',
+        description: 'Get cost summary (today, 7-day, 30-day, per-tab).',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string', description: 'Filter to a single tab' } },
+        },
+    },
+    {
+        name: 'beecork_failed_deliveries',
+        description: 'List recent messages that failed to deliver via channels.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_activity',
+        description: 'Get activity summary for the last N hours.',
+        inputSchema: {
+            type: 'object',
+            properties: { hours: { type: 'number', description: 'Lookback window (default 24)' } },
+        },
+    },
+    {
+        name: 'beecork_export_data',
+        description: 'Export historical data as JSON for analysis.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['costs', 'messages', 'crons'],
+                    description: 'What to export',
+                },
+                days: { type: 'number', description: 'Lookback window in days (default 30)' },
+            },
+            required: ['type'],
+        },
+    },
+    {
+        name: 'beecork_handoff',
+        description: "Get info to resume a tab's session in your terminal.",
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string' } },
+            required: ['tabName'],
+        },
+    },
+    {
+        name: 'beecork_delegate',
+        description: 'Delegate a sub-task to another tab. The result will be sent back when complete.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tabName: { type: 'string', description: 'Tab to delegate to' },
+                message: { type: 'string', description: 'The task description' },
+                returnToTab: {
+                    type: 'string',
+                    description: 'Tab to notify when complete (default: "default")',
+                },
+            },
+            required: ['tabName', 'message'],
+        },
+    },
+    {
+        name: 'beecork_delegation_status',
+        description: 'List pending delegations.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string', description: 'Filter by source or target tab' } },
+        },
+    },
+    {
+        name: 'beecork_project_create',
+        description: 'Register a project folder so the router can detect it from natural language.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Project name (also the folder name)' },
+                path: {
+                    type: 'string',
+                    description: 'Optional parent directory (must be under a scan path)',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'beecork_project_list',
+        description: 'List registered projects/folders.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_close_tab',
+        description: 'Permanently close a tab — stops its subprocess and deletes its message history.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string' } },
+            required: ['tabName'],
+        },
+    },
+    {
+        name: 'beecork_generate_image',
+        description: 'Generate an image via a configured media provider (DALL-E, Recraft, etc.).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                style: { type: 'string' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_generate_video',
+        description: 'Generate a video via a configured media provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                duration: { type: 'number' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_generate_audio',
+        description: 'Generate audio via a configured media provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_media_providers',
+        description: 'List configured media generators and what they support.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_knowledge',
+        description: 'List all stored knowledge (memories + knowledge files), optionally filtered by scope.',
+        inputSchema: {
+            type: 'object',
+            properties: { scope: { type: 'string', enum: ['global', 'project', 'tab', 'all'] } },
+        },
+    },
+    {
+        name: 'beecork_capabilities',
+        description: 'List available capability packs and their status.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_history',
+        description: 'Get the activity timeline for a given day/tab.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'ISO date YYYY-MM-DD (default: today)' },
+                tabName: { type: 'string' },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'beecork_replay',
+        description: 'Re-run a past activity event by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { eventId: { type: 'string' } },
+            required: ['eventId'],
+        },
+    },
+    {
+        name: 'beecork_store_search',
+        description: 'Search the Beecork community extension registry (npm packages starting with "beecork-").',
+        inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string' } },
+            required: ['query'],
+        },
+    },
+];

package/dist/mcp/validate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal MCP tool-input validator. Walks the declared `inputSchema` from
+ * `tool-definitions.ts` and rejects calls that violate `required`, `type`, or
+ * `enum`. Handlers previously had ad-hoc checks for some fields and silently
+ * accepted invalid inputs for others — this single validator converts the
+ * inconsistency into a uniform "Invalid input: ..." failure.
+ *
+ * Deliberately handwritten (no Ajv/zod dep) to avoid pulling a runtime dep
+ * for one validation pass.
+ */
+interface PropertySchema {
+    type?: string | string[];
+    enum?: readonly unknown[];
+    items?: PropertySchema;
+    description?: string;
+}
+export interface InputSchema {
+    type?: string;
+    properties?: Record<string, PropertySchema>;
+    required?: readonly string[];
+}
+export declare function validateToolArgs(schema: unknown, args: Record<string, unknown> | undefined): string | null;
+export {};

package/dist/mcp/validate.js

@@ -0,0 +1,65 @@
+/**
+ * Minimal MCP tool-input validator. Walks the declared `inputSchema` from
+ * `tool-definitions.ts` and rejects calls that violate `required`, `type`, or
+ * `enum`. Handlers previously had ad-hoc checks for some fields and silently
+ * accepted invalid inputs for others — this single validator converts the
+ * inconsistency into a uniform "Invalid input: ..." failure.
+ *
+ * Deliberately handwritten (no Ajv/zod dep) to avoid pulling a runtime dep
+ * for one validation pass.
+ */
+export function validateToolArgs(schema, args) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const s = schema;
+    const a = args || {};
+    // Required fields
+    for (const field of s.required ?? []) {
+        const value = a[field];
+        if (value === undefined || value === null || value === '') {
+            return `Invalid input: "${field}" is required`;
+        }
+    }
+    // Per-property type/enum checks
+    for (const [field, propSchema] of Object.entries(s.properties ?? {})) {
+        const value = a[field];
+        if (value === undefined || value === null)
+            continue;
+        const typeError = checkType(value, propSchema, field);
+        if (typeError)
+            return typeError;
+        if (propSchema.enum && !propSchema.enum.includes(value)) {
+            return `Invalid input: "${field}" must be one of ${JSON.stringify(propSchema.enum)} (got ${JSON.stringify(value)})`;
+        }
+    }
+    return null;
+}
+function checkType(value, schema, field) {
+    if (!schema.type)
+        return null;
+    const types = (Array.isArray(schema.type) ? schema.type : [schema.type]);
+    for (const t of types) {
+        if (matchesType(value, t))
+            return null;
+    }
+    return `Invalid input: "${field}" must be ${types.join(' | ')} (got ${typeof value})`;
+}
+function matchesType(value, t) {
+    switch (t) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        default:
+            // Unknown types fall through to accept (lenient).
+            return true;
+    }
+}

package/dist/media/factory.js

@@ -9,24 +9,28 @@ import { NanoBananaGenerator } from './generators/nano-banana.js';
 import { ElevenLabsMusicGenerator } from './generators/elevenlabs-music.js';
 import { LyriaGenerator } from './generators/lyria.js';
 import { RecraftGenerator } from './generators/recraft.js';
+// Lookup table — adding a new generator becomes one entry instead of one switch case.
+const GENERATOR_BUILDERS = {
+    'dall-e': (k, m) => new DalleGenerator(k, m),
+    'stable-diffusion': (k) => new StableDiffusionGenerator(k),
+    runway: (k) => new RunwayGenerator(k),
+    veo: (k) => new VeoGenerator(k),
+    kling: (k) => new KlingGenerator(k),
+    'elevenlabs-sfx': (k) => new ElevenLabsSfxGenerator(k),
+    'nano-banana': (k, m) => new NanoBananaGenerator(k, m),
+    'elevenlabs-music': (k) => new ElevenLabsMusicGenerator(k),
+    lyria: (k, m) => new LyriaGenerator(k, m),
+    recraft: (k) => new RecraftGenerator(k),
+};
 export function createMediaGenerator(config) {
     if (!config.apiKey) {
         logger.warn(`Media generator ${config.provider}: missing API key`);
         return null;
     }
-    switch (config.provider) {
-        case 'dall-e': return new DalleGenerator(config.apiKey, config.model);
-        case 'stable-diffusion': return new StableDiffusionGenerator(config.apiKey);
-        case 'runway': return new RunwayGenerator(config.apiKey);
-        case 'veo': return new VeoGenerator(config.apiKey);
-        case 'kling': return new KlingGenerator(config.apiKey);
-        case 'elevenlabs-sfx': return new ElevenLabsSfxGenerator(config.apiKey);
-        case 'nano-banana': return new NanoBananaGenerator(config.apiKey, config.model);
-        case 'elevenlabs-music': return new ElevenLabsMusicGenerator(config.apiKey);
-        case 'lyria': return new LyriaGenerator(config.apiKey, config.model);
-        case 'recraft': return new RecraftGenerator(config.apiKey);
-        default:
-            logger.warn(`Unknown media generator: ${config.provider}`);
-            return null;
+    const build = GENERATOR_BUILDERS[config.provider];
+    if (!build) {
+        logger.warn(`Unknown media generator: ${config.provider}`);
+        return null;
     }
+    return build(config.apiKey, config.model);
 }

package/dist/media/generators/dall-e.js

@@ -16,7 +16,7 @@ export class DalleGenerator {
         const response = await fetch('https://api.openai.com/v1/images/generations', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -33,7 +33,7 @@ export class DalleGenerator {
             const err = await response.text();
             throw new Error(`DALL-E error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const buffer = Buffer.from(data.data[0].b64_json, 'base64');
         const filePath = saveMedia(buffer, 'png', 'generated-image.png');
         return { filePath, mimeType: 'image/png' };

package/dist/media/generators/kling.js

@@ -14,7 +14,7 @@ export class KlingGenerator {
         const response = await fetch('https://api.klingai.com/v1/videos/text2video', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -28,14 +28,14 @@ export class KlingGenerator {
             const err = await response.text();
             throw new Error(`Kling error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const { data } = await response.json();
+        const { data } = (await response.json());
         // Poll for completion
-        const headers = { 'Authorization': `Bearer ${this.apiKey}` };
+        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,
+            isFailed: (d) => (d.data.task_status === 'failed' ? 'generation failed' : null),
             getResultUrl: (d) => d.data.task_result.videos[0].url,
             label: 'Kling',
         });

package/dist/media/generators/lyria.js

@@ -29,7 +29,7 @@ export class LyriaGenerator {
             const err = await response.text();
             throw new Error(`Lyria error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        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');

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

@@ -6,5 +6,5 @@ export declare class NanoBananaGenerator implements MediaGenerator {
     readonly name = "Google Nano Banana";
     readonly supportedTypes: MediaType[];
     constructor(apiKey: string, model?: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    generate(type: MediaType, prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
 }

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

@@ -9,7 +9,7 @@ export class NanoBananaGenerator {
         this.apiKey = apiKey;
         this.model = model;
     }
-    async generate(type, prompt, options) {
+    async generate(type, prompt, _options) {
         if (type !== 'image')
             throw new Error('Nano Banana only supports image generation');
         // Gemini image generation API
@@ -31,7 +31,7 @@ export class NanoBananaGenerator {
             const err = await response.text();
             throw new Error(`Nano Banana error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        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');

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

@@ -1,8 +1,8 @@
 import { logger } from '../../util/logger.js';
 export async function pollForCompletion(opts) {
-    const { statusUrl, headers, isComplete, isFailed, getResultUrl, interval = 5000, maxAttempts = 60, label = 'API' } = 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));
+        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}`);
@@ -11,12 +11,12 @@ export async function pollForCompletion(opts) {
             }
             continue;
         }
-        const data = await resp.json();
+        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`);
+    throw new Error(`${label} generation timed out after ${(maxAttempts * interval) / 1000}s`);
 }