beecork 1.7.1 → 2.0.1

package/dist/channels/whatsapp.js

@@ -1,323 +0,0 @@
-/*
- * WhatsApp integration via @whiskeysockets/baileys.
- *
- * baileys is a peer-optional dependency loaded by dynamic import, and its
- * runtime types are intentionally loose (the lib uses heavy union/index
- * types that don't survive serialization across the dynamic-import boundary).
- * Trying to type every variant of Baileys' message/connection shapes would
- * either pull baileys into the static graph (bloating non-WhatsApp installs)
- * or require maintaining a parallel shim. We accept `any` at this trust
- * boundary; runtime validation lives in the descriptors table inside
- * messages.upsert.
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import fs from 'node:fs';
-import { logger } from '../util/logger.js';
-import { saveMedia, isOversized } from '../media/store.js';
-import { sendChunkedResponse } from './send-helpers.js';
-import { inboundLimiter } from '../util/rate-limiter.js';
-import { processInboundMessage } from './pipeline.js';
-import { isChannelAdmin } from './admin.js';
-import { VoiceState } from './voice-state.js';
-const WHATSAPP_MAX_LENGTH = 8192;
-export class WhatsAppChannel {
-    id = 'whatsapp';
-    name = 'WhatsApp';
-    maxMessageLength = WHATSAPP_MAX_LENGTH;
-    sock = null;
-    ctx;
-    allowedNumbers;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 10;
-    backoffDelays = [1000, 5000, 15000, 30000, 60000];
-    voice = new VoiceState('whatsapp');
-    constructor(ctx) {
-        this.ctx = ctx;
-        this.allowedNumbers = new Set(ctx.config.whatsapp?.allowedNumbers ?? []);
-    }
-    /**
-     * Schedule the next reconnect with exponential backoff. Unlike the previous
-     * inline setTimeout, this path retries when `start()` itself rejects (auth
-     * failure, baileys init throw, etc.) instead of going permanently silent
-     * after a single failed attempt.
-     */
-    scheduleReconnect() {
-        this.reconnectAttempts++;
-        if (this.reconnectAttempts > this.maxReconnectAttempts) {
-            logger.error(`WhatsApp reconnect failed after ${this.maxReconnectAttempts} attempts, giving up`);
-            this.ctx
-                .notifyCallback?.('⚠️ WhatsApp disconnected after 10 reconnection attempts. Restart daemon to reconnect.')
-                .catch((err) => logger.error('Failed to send WhatsApp disconnect notification:', err));
-            return;
-        }
-        const delayIdx = Math.min(this.reconnectAttempts - 1, this.backoffDelays.length - 1);
-        const delay = this.backoffDelays[delayIdx];
-        logger.warn(`WhatsApp connection closed, reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
-        setTimeout(() => {
-            this.start().catch((err) => {
-                logger.error('WhatsApp reconnect attempt failed:', err);
-                // Recurse via scheduleReconnect so backoff keeps escalating instead of
-                // silently dropping the reconnect chain after one failed start().
-                this.scheduleReconnect();
-            });
-        }, delay);
-    }
-    async start() {
-        // Initialize voice providers (STT + TTS)
-        this.voice.init(this.ctx.config);
-        try {
-            const { default: makeWASocket, useMultiFileAuthState, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, } = await import('@whiskeysockets/baileys');
-            const { getWhatsappSessionPath } = await import('../util/paths.js');
-            // Use the centralized path helper — the previous fallback hard-coded
-            // process.env.HOME which bypassed BEECORK_HOME for tests/isolation.
-            const sessionPath = this.ctx.config.whatsapp?.sessionPath ?? getWhatsappSessionPath();
-            fs.mkdirSync(sessionPath, { recursive: true, mode: 0o700 });
-            const { state, saveCreds } = await useMultiFileAuthState(sessionPath);
-            const { version } = await fetchLatestBaileysVersion().catch(() => ({ version: undefined }));
-            const pino = (await import('pino')).default;
-            this.sock = makeWASocket({
-                auth: state,
-                version,
-                logger: pino({ level: 'silent' }),
-            });
-            const sock = this.sock;
-            sock.ev.on('creds.update', saveCreds);
-            sock.ev.on('connection.update', async (update) => {
-                const { connection, lastDisconnect, qr } = update;
-                if (qr) {
-                    try {
-                        const qrcodeTerminal = await import('qrcode-terminal');
-                        (qrcodeTerminal.default || qrcodeTerminal).generate(qr, { small: true });
-                        logger.info('WhatsApp QR code displayed — scan with your phone');
-                    }
-                    catch {
-                        logger.warn('WhatsApp QR code available but could not render. Install qrcode-terminal.');
-                    }
-                }
-                if (connection === 'close') {
-                    const reason = lastDisconnect?.error?.output?.statusCode;
-                    if (reason !== DisconnectReason.loggedOut) {
-                        this.scheduleReconnect();
-                    }
-                    else {
-                        logger.error('WhatsApp logged out. Please re-scan QR code.');
-                    }
-                }
-                else if (connection === 'open') {
-                    this.reconnectAttempts = 0;
-                    logger.info('WhatsApp connected');
-                }
-            });
-            sock.ev.on('messages.upsert', async (m) => {
-                const msg = m.messages[0];
-                if (!msg?.message || msg.key.fromMe)
-                    return;
-                const sender = msg.key.remoteJid;
-                if (!sender || !this.isAllowed(sender))
-                    return;
-                // Rate limit check
-                if (!inboundLimiter.check(this.id)) {
-                    await sock
-                        .sendMessage(sender, {
-                        text: "I'm receiving too many messages right now. Please wait a moment.",
-                    })
-                        .catch(() => { });
-                    return;
-                }
-                const text = msg.message.conversation ||
-                    msg.message.extendedTextMessage?.text ||
-                    msg.message.imageMessage?.caption ||
-                    msg.message.videoMessage?.caption ||
-                    '';
-                const descriptors = [
-                    {
-                        key: 'imageMessage',
-                        build: (m, buf) => ({
-                            type: 'image',
-                            mimeType: m.imageMessage.mimetype || 'image/jpeg',
-                            filePath: saveMedia(buf, 'jpg'),
-                        }),
-                    },
-                    {
-                        key: 'audioMessage',
-                        build: (m, buf) => {
-                            const ext = m.audioMessage.ptt ? 'ogg' : 'mp3';
-                            return {
-                                type: m.audioMessage.ptt ? 'voice' : 'audio',
-                                mimeType: m.audioMessage.mimetype || 'audio/ogg',
-                                filePath: saveMedia(buf, ext),
-                                duration: m.audioMessage.seconds ?? undefined,
-                            };
-                        },
-                    },
-                    {
-                        key: 'documentMessage',
-                        build: (m, buf) => {
-                            const ext = m.documentMessage.fileName?.split('.').pop() || 'bin';
-                            return {
-                                type: 'document',
-                                mimeType: m.documentMessage.mimetype || 'application/octet-stream',
-                                filePath: saveMedia(buf, ext, m.documentMessage.fileName ?? undefined),
-                                fileName: m.documentMessage.fileName ?? undefined,
-                            };
-                        },
-                    },
-                    {
-                        key: 'videoMessage',
-                        build: (m, buf) => ({
-                            type: 'video',
-                            mimeType: m.videoMessage.mimetype || 'video/mp4',
-                            filePath: saveMedia(buf, 'mp4'),
-                            duration: m.videoMessage.seconds ?? undefined,
-                        }),
-                    },
-                ];
-                const waDownloadTasks = [];
-                for (const d of descriptors) {
-                    if (!msg.message[d.key])
-                        continue;
-                    waDownloadTasks.push(downloadMediaMessage(msg, 'buffer', {})
-                        .then((buffer) => {
-                        if (!buffer || isOversized(buffer.length))
-                            return null;
-                        try {
-                            return d.build(msg.message, buffer);
-                        }
-                        catch {
-                            return null;
-                        }
-                    })
-                        .catch(() => null));
-                }
-                const waResults = await Promise.allSettled(waDownloadTasks);
-                const media = waResults
-                    .filter((r) => r.status === 'fulfilled' && r.value !== null)
-                    .map((r) => r.value);
-                // Transcribe voice messages if STT is configured
-                await this.voice.transcribe(media);
-                if (!text && media.length === 0)
-                    return;
-                try {
-                    const waUserId = sender.replace('@s.whatsapp.net', '');
-                    // Shared command handler (covers /tabs, /stop, /projects, /project, /newproject, /close, /fresh, etc.)
-                    if (text.startsWith('/')) {
-                        const { handleSharedCommand } = await import('./command-handler.js');
-                        const cmdResult = await handleSharedCommand({
-                            userId: waUserId,
-                            text,
-                            isAdmin: isChannelAdmin(this.allowedNumbers, waUserId, this.ctx.config.whatsapp?.adminNumber),
-                            channelId: 'whatsapp',
-                        }, this.ctx.tabManager);
-                        if (cmdResult.handled) {
-                            if (cmdResult.response)
-                                await sock.sendMessage(sender, { text: cmdResult.response });
-                            return;
-                        }
-                    }
-                    await sock.sendPresenceUpdate('composing', sender).catch(() => { });
-                    // Shared message pipeline
-                    const pipelineResult = await processInboundMessage({
-                        text,
-                        media,
-                        channelId: 'whatsapp',
-                        tabManager: this.ctx.tabManager,
-                        voiceReplyMode: this.ctx.config.voice?.replyMode,
-                        ttsProvider: this.voice.tts,
-                        userId: waUserId,
-                        sendProgress: (msg) => {
-                            sock.sendMessage(sender, { text: msg }).catch(() => { });
-                        },
-                    });
-                    await sock.sendPresenceUpdate('paused', sender).catch(() => { });
-                    // Empty result means no prompt and no media
-                    if (!pipelineResult.responseText)
-                        return;
-                    // Send voice reply if TTS generated audio
-                    if (pipelineResult.audioPath) {
-                        await sock.sendMessage(sender, {
-                            audio: { url: pipelineResult.audioPath },
-                            mimetype: 'audio/ogg; codecs=opus',
-                            ptt: true,
-                        });
-                        if (pipelineResult.voiceOnly)
-                            return;
-                    }
-                    await this.sendResponse(sender, pipelineResult.responseText, pipelineResult.tabName);
-                }
-                catch (err) {
-                    logger.error('WhatsApp message handler error:', err);
-                    await sock
-                        .sendMessage(sender, {
-                        text: 'Something went wrong processing your message. Check daemon logs for details.',
-                    })
-                        .catch((sendErr) => logger.error('WhatsApp: failed to send fallback error message:', sendErr));
-                }
-            });
-        }
-        catch (err) {
-            logger.error('Failed to start WhatsApp client:', err);
-            throw err;
-        }
-    }
-    stop() {
-        const sock = this.sock;
-        if (sock) {
-            sock.end(undefined);
-            this.sock = null;
-        }
-        logger.info('WhatsApp client stopped');
-    }
-    async sendMessage(peerId, text, _options) {
-        const sock = this.sock;
-        if (!sock)
-            return;
-        await sendChunkedResponse({
-            text,
-            maxLength: WHATSAPP_MAX_LENGTH,
-            retryLabel: 'whatsapp-send',
-            sendChunk: (chunk) => sock.sendMessage(peerId, { text: chunk }),
-        });
-    }
-    async sendNotification(message, _urgent) {
-        const sock = this.sock;
-        if (!sock)
-            return;
-        for (const number of this.allowedNumbers) {
-            try {
-                await sock.sendMessage(`${number}@s.whatsapp.net`, { text: message });
-            }
-            catch (err) {
-                logger.error(`Failed to send WhatsApp notification to ${number}:`, err);
-            }
-        }
-    }
-    async setTyping(peerId, active) {
-        const sock = this.sock;
-        if (!sock)
-            return;
-        const status = active ? 'composing' : 'paused';
-        await sock.sendPresenceUpdate(status, peerId).catch(() => { });
-    }
-    // ─── Private ───
-    async sendResponse(jid, text, tabName) {
-        const sock = this.sock;
-        try {
-            await sendChunkedResponse({
-                text,
-                tabName,
-                maxLength: WHATSAPP_MAX_LENGTH,
-                retryLabel: 'whatsapp-send',
-                sendChunk: (chunk) => sock.sendMessage(jid, { text: chunk }),
-            });
-        }
-        catch (err) {
-            logger.error(`WhatsApp delivery failed for ${jid}:`, err);
-        }
-    }
-    isAllowed(jid) {
-        if (this.allowedNumbers.size === 0)
-            return false;
-        const number = jid.replace('@s.whatsapp.net', '');
-        return this.allowedNumbers.has(number);
-    }
-}

package/dist/cli/capabilities.d.ts

@@ -1,3 +0,0 @@
-export declare function enableCapability(packId: string): Promise<void>;
-export declare function listCapabilities(): Promise<void>;
-export declare function disableCapability(packId: string): Promise<void>;

package/dist/cli/capabilities.js

@@ -1,72 +0,0 @@
-import readline from 'node:readline';
-function ask(rl, question, defaultValue) {
-    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
-    return new Promise((r) => rl.question(prompt, (a) => r(a.trim() || defaultValue || '')));
-}
-export async function enableCapability(packId) {
-    const { getAvailablePacks, isEnabled, enablePack } = await import('../capabilities/index.js');
-    const packs = getAvailablePacks();
-    const pack = packs.find((p) => p.id === packId);
-    if (!pack) {
-        console.log(`Unknown capability: "${packId}"`);
-        console.log('Available: ' + packs.map((p) => p.id).join(', '));
-        return;
-    }
-    if (isEnabled(packId)) {
-        console.log(`${pack.name} is already enabled. Re-configuring...`);
-    }
-    console.log(`\n${pack.name}`);
-    console.log(`  ${pack.description}\n`);
-    let apiKey;
-    if (pack.requiresApiKey) {
-        if (pack.setupUrl) {
-            console.log(`  Setup guide: ${pack.setupUrl}\n`);
-        }
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        apiKey = await ask(rl, `  ${pack.apiKeyHint || 'API key'}`);
-        rl.close();
-        if (!apiKey) {
-            console.log('  No API key provided. Cancelled.');
-            return;
-        }
-    }
-    enablePack(packId, apiKey);
-    console.log(`\n✓ ${pack.name} enabled.`);
-    console.log('  Restart daemon to activate: beecork stop && beecork start\n');
-}
-export async function listCapabilities() {
-    const { getAvailablePacks, isEnabled } = await import('../capabilities/index.js');
-    const packs = getAvailablePacks();
-    console.log('\nCapabilities:\n');
-    const categories = ['productivity', 'development', 'data', 'web'];
-    const categoryNames = {
-        productivity: 'Productivity',
-        development: 'Development',
-        data: 'Data',
-        web: 'Web',
-    };
-    for (const category of categories) {
-        const categoryPacks = packs.filter((p) => p.category === category);
-        if (categoryPacks.length === 0)
-            continue;
-        console.log(`  ${categoryNames[category]}:`);
-        for (const pack of categoryPacks) {
-            const status = isEnabled(pack.id) ? '✓' : '○';
-            const keyNeeded = pack.requiresApiKey ? ' (needs API key)' : '';
-            console.log(`    ${status} ${pack.id} — ${pack.name}${keyNeeded}`);
-        }
-        console.log('');
-    }
-    console.log('  Enable: beecork enable <name>');
-    console.log('  Example: beecork enable github\n');
-}
-export async function disableCapability(packId) {
-    const { disablePack, isEnabled } = await import('../capabilities/index.js');
-    if (!isEnabled(packId)) {
-        console.log(`${packId} is not enabled.`);
-        return;
-    }
-    disablePack(packId);
-    console.log(`\n✓ ${packId} disabled.`);
-    console.log('  Restart daemon to apply: beecork stop && beecork start\n');
-}

package/dist/cli/channel.d.ts

@@ -1,3 +0,0 @@
-export declare function channelInstall(packageName: string): void;
-export declare function channelCreate(name: string): void;
-export declare function channelList(): void;

package/dist/cli/channel.js

@@ -1,202 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-const CHANNEL_PREFIX = 'beecork-channel-';
-const SAFE_NPM_PACKAGE = /^[@a-zA-Z0-9_/.-]+$/;
-export function channelInstall(packageName) {
-    // Normalize name
-    const fullName = packageName.startsWith(CHANNEL_PREFIX)
-        ? packageName
-        : `${CHANNEL_PREFIX}${packageName}`;
-    if (!SAFE_NPM_PACKAGE.test(fullName)) {
-        console.error(`Invalid package name: ${fullName}`);
-        process.exit(1);
-    }
-    console.log(`Installing channel: ${fullName}...`);
-    try {
-        execFileSync('npm', ['install', '-g', fullName], { stdio: 'inherit' });
-        console.log(`\nChannel "${fullName}" installed.`);
-        console.log('Restart the daemon to activate: beecork stop && beecork start');
-    }
-    catch {
-        console.error(`Failed to install ${fullName}. Check the package name and try again.`);
-        process.exit(1);
-    }
-}
-export function channelCreate(name) {
-    const pkgName = `${CHANNEL_PREFIX}${name}`;
-    const dir = pkgName;
-    if (fs.existsSync(dir)) {
-        console.error(`Directory "${dir}" already exists.`);
-        process.exit(1);
-    }
-    fs.mkdirSync(dir, { recursive: true });
-    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
-    // package.json
-    fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({
-        name: pkgName,
-        version: '0.1.0',
-        description: `Beecork channel: ${name}`,
-        main: 'dist/index.js',
-        type: 'module',
-        scripts: {
-            build: 'tsc',
-            dev: 'tsc --watch',
-        },
-        keywords: ['beecork', 'beecork-channel', name],
-        peerDependencies: {
-            beecork: '>=0.4.0',
-        },
-        devDependencies: {
-            typescript: '^5.7.0',
-            '@types/node': '^22.0.0',
-        },
-    }, null, 2) + '\n');
-    // tsconfig.json
-    fs.writeFileSync(path.join(dir, 'tsconfig.json'), JSON.stringify({
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'NodeNext',
-            moduleResolution: 'NodeNext',
-            outDir: 'dist',
-            rootDir: 'src',
-            strict: true,
-            esModuleInterop: true,
-            declaration: true,
-        },
-        include: ['src'],
-    }, null, 2) + '\n');
-    // Main source file
-    const className = name.charAt(0).toUpperCase() + name.slice(1);
-    fs.writeFileSync(path.join(dir, 'src', 'index.ts'), `// ${pkgName} — Beecork channel implementation
-// See: https://github.com/beecork/beecork for Channel interface docs
-
-// Import the Channel interface type from beecork
-// Note: beecork is a peer dependency
-interface Channel {
-  readonly id: string;
-  readonly name: string;
-  readonly maxMessageLength: number;
-  readonly supportsStreaming: boolean;
-  readonly supportsMedia: boolean;
-  start(): Promise<void>;
-  stop(): void;
-  sendMessage(peerId: string, text: string): Promise<void>;
-  sendNotification(message: string, urgent?: boolean): Promise<void>;
-  setTyping(peerId: string, active: boolean): Promise<void>;
-  onMessage(handler: (msg: any) => Promise<void>): void;
-}
-
-interface ChannelContext {
-  config: any;
-  tabManager: any;
-}
-
-export default class ${className}Channel implements Channel {
-  readonly id = '${name}';
-  readonly name = '${className}';
-  readonly maxMessageLength = 4096;
-  readonly supportsStreaming = false;
-  readonly supportsMedia = false;
-
-  private ctx: ChannelContext;
-  private handler: ((msg: any) => Promise<void>) | null = null;
-
-  constructor(ctx: ChannelContext) {
-    this.ctx = ctx;
-  }
-
-  async start(): Promise<void> {
-    // TODO: Connect to your service, start polling/websocket
-    console.log(\`${name} channel started\`);
-  }
-
-  stop(): void {
-    // TODO: Disconnect, cleanup
-    console.log(\`${name} channel stopped\`);
-  }
-
-  onMessage(handler: (msg: any) => Promise<void>): void {
-    this.handler = handler;
-  }
-
-  async sendMessage(peerId: string, text: string): Promise<void> {
-    // TODO: Send a message to the user
-  }
-
-  async sendNotification(message: string, urgent?: boolean): Promise<void> {
-    // TODO: Send a notification to all configured users
-  }
-
-  async setTyping(peerId: string, active: boolean): Promise<void> {
-    // TODO: Show typing indicator
-  }
-}
-`);
-    // README
-    fs.writeFileSync(path.join(dir, 'README.md'), `# ${pkgName}
-
-A Beecork channel plugin for ${name}.
-
-## Installation
-
-\`\`\`bash
-beecork channel install ${name}
-# or: npm install -g ${pkgName}
-\`\`\`
-
-## Configuration
-
-Add to your \`~/.beecork/config.json\`:
-
-\`\`\`json
-{
-  "${name}": {
-    "enabled": true
-  }
-}
-\`\`\`
-
-## Development
-
-\`\`\`bash
-npm install
-npm run build
-\`\`\`
-
-## Publishing
-
-\`\`\`bash
-npm publish
-\`\`\`
-`);
-    console.log(`\nChannel scaffold created: ${dir}/`);
-    console.log(`\nNext steps:`);
-    console.log(`  cd ${dir}`);
-    console.log(`  npm install`);
-    console.log(`  # Edit src/index.ts to implement your channel`);
-    console.log(`  npm run build`);
-    console.log(`  npm publish`);
-}
-export function channelList() {
-    try {
-        const output = execFileSync('npm', ['list', '-g', '--depth=0'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const lines = output.split('\n').filter((line) => line.includes(CHANNEL_PREFIX));
-        if (lines.length === 0) {
-            console.log('No community channels installed.');
-            console.log(`Install one: beecork channel install <name>`);
-            return;
-        }
-        console.log(`\n${lines.length} community channel(s):\n`);
-        for (const line of lines) {
-            console.log(`  ${line.trim()}`);
-        }
-        console.log('');
-    }
-    catch {
-        console.log('No community channels installed.');
-    }
-}

package/dist/cli/commands.d.ts

@@ -1,15 +0,0 @@
-export declare function startDaemon(): Promise<void>;
-export declare function stopDaemon(): Promise<void>;
-export declare function showStatus(): Promise<void>;
-export declare function listTabs(): Promise<void>;
-export declare function tailLogs(tabName?: string): Promise<void>;
-export declare function listCrons(): Promise<void>;
-export declare function deleteCron(id: string): Promise<void>;
-export declare function listWatchers(): Promise<void>;
-export declare function deleteWatcher(id: string): Promise<void>;
-export declare function listMemories(): Promise<void>;
-export declare function deleteMemory(id: string): Promise<void>;
-export declare function updateBeecork(options: {
-    check?: boolean;
-}): Promise<void>;
-export declare function sendMessage(message: string): Promise<void>;