beecork 1.7.1 → 2.0.0

package/dist/voice/stt.d.ts

@@ -1,16 +0,0 @@
-export interface STTProvider {
-    transcribe(filePath: string): Promise<string>;
-    warmup?(): Promise<void>;
-}
-/** OpenAI Whisper API provider */
-export declare class WhisperAPIProvider implements STTProvider {
-    private apiKey;
-    constructor(apiKey: string);
-    warmup(): Promise<void>;
-    transcribe(filePath: string): Promise<string>;
-}
-/** Create STT provider from config */
-export declare function createSTTProvider(config: {
-    provider: string;
-    apiKey?: string;
-}): STTProvider | null;

package/dist/voice/stt.js

@@ -1,57 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { logger } from '../util/logger.js';
-import { assertInsideMediaDir } from '../media/store.js';
-/** OpenAI Whisper API provider */
-export class WhisperAPIProvider {
-    apiKey;
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-    }
-    async warmup() {
-        try {
-            // Make a lightweight request to warm up the HTTPS connection
-            await fetch('https://api.openai.com/v1/models', {
-                headers: { Authorization: `Bearer ${this.apiKey}` },
-                signal: AbortSignal.timeout(5000),
-            });
-        }
-        catch {
-            /* non-critical */
-        }
-    }
-    async transcribe(filePath) {
-        // Defense-in-depth: callers should already constrain filePath to the media dir,
-        // but verify here so a leaked/forged MediaAttachment.filePath cannot exfiltrate
-        // arbitrary files (e.g. ~/.ssh/id_rsa) to the Whisper API.
-        const safePath = assertInsideMediaDir(filePath);
-        const buffer = await readFile(safePath);
-        const formData = new FormData();
-        formData.append('file', new Blob([buffer]), 'audio.ogg');
-        formData.append('model', 'whisper-1');
-        const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${this.apiKey}` },
-            body: formData,
-            signal: AbortSignal.timeout(60000),
-        });
-        if (!response.ok) {
-            throw new Error(`Whisper API error: ${response.status} ${response.statusText}`);
-        }
-        const result = (await response.json());
-        return result.text;
-    }
-}
-/** Create STT provider from config */
-export function createSTTProvider(config) {
-    switch (config.provider) {
-        case 'whisper-api':
-            if (!config.apiKey) {
-                logger.warn('Whisper API key not configured, voice transcription disabled');
-                return null;
-            }
-            return new WhisperAPIProvider(config.apiKey);
-        default:
-            logger.warn(`Unknown STT provider: ${config.provider}`);
-            return null;
-    }
-}

package/dist/voice/tts.d.ts

@@ -1,23 +0,0 @@
-export interface TTSProvider {
-    synthesize(text: string): Promise<string>;
-}
-/** OpenAI TTS API provider */
-export declare class OpenAITTSProvider implements TTSProvider {
-    private apiKey;
-    private voice;
-    constructor(apiKey: string, voice?: string);
-    synthesize(text: string): Promise<string>;
-}
-/** ElevenLabs TTS provider */
-export declare class ElevenLabsTTSProvider implements TTSProvider {
-    private apiKey;
-    private voiceId;
-    constructor(apiKey: string, voiceId?: string);
-    synthesize(text: string): Promise<string>;
-}
-/** Create TTS provider from config */
-export declare function createTTSProvider(config: {
-    provider: string;
-    apiKey?: string;
-    voice?: string;
-}): TTSProvider | null;

package/dist/voice/tts.js

@@ -1,84 +0,0 @@
-import { logger } from '../util/logger.js';
-import { saveMedia } from '../media/store.js';
-/** OpenAI TTS API provider */
-export class OpenAITTSProvider {
-    apiKey;
-    voice;
-    constructor(apiKey, voice = 'alloy') {
-        this.apiKey = apiKey;
-        this.voice = voice;
-    }
-    async synthesize(text) {
-        // Truncate very long text (TTS has limits)
-        const truncated = text.slice(0, 4096);
-        const response = await fetch('https://api.openai.com/v1/audio/speech', {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: 'tts-1',
-                input: truncated,
-                voice: this.voice,
-                response_format: 'opus',
-            }),
-            signal: AbortSignal.timeout(60000),
-        });
-        if (!response.ok) {
-            throw new Error(`TTS API error: ${response.status} ${response.statusText}`);
-        }
-        const buffer = Buffer.from(await response.arrayBuffer());
-        return saveMedia(buffer, 'ogg', 'voice-reply.ogg');
-    }
-}
-/** ElevenLabs TTS provider */
-export class ElevenLabsTTSProvider {
-    apiKey;
-    voiceId;
-    constructor(apiKey, voiceId = '21m00Tcm4TlvDq8ikWAM') {
-        this.apiKey = apiKey;
-        this.voiceId = voiceId;
-    }
-    async synthesize(text) {
-        const truncated = text.slice(0, 5000);
-        const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${this.voiceId}`, {
-            method: 'POST',
-            headers: {
-                'xi-api-key': this.apiKey,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                text: truncated,
-                model_id: 'eleven_monolingual_v1',
-                output_format: 'mp3_44100_128',
-            }),
-            signal: AbortSignal.timeout(60000),
-        });
-        if (!response.ok) {
-            throw new Error(`ElevenLabs API error: ${response.status} ${response.statusText}`);
-        }
-        const buffer = Buffer.from(await response.arrayBuffer());
-        return saveMedia(buffer, 'mp3', 'voice-reply.mp3');
-    }
-}
-/** Create TTS provider from config */
-export function createTTSProvider(config) {
-    switch (config.provider) {
-        case 'openai':
-            if (!config.apiKey) {
-                logger.warn('OpenAI API key not configured for TTS');
-                return null;
-            }
-            return new OpenAITTSProvider(config.apiKey, config.voice);
-        case 'elevenlabs':
-            if (!config.apiKey) {
-                logger.warn('ElevenLabs API key not configured for TTS');
-                return null;
-            }
-            return new ElevenLabsTTSProvider(config.apiKey, config.voice);
-        default:
-            logger.warn(`Unknown TTS provider: ${config.provider}`);
-            return null;
-    }
-}

package/dist/watchers/evaluator.d.ts

@@ -1,5 +0,0 @@
-import type { Watcher } from './types.js';
-export declare function evaluateWatcher(watcher: Watcher): Promise<{
-    triggered: boolean;
-    output: string;
-}>;

package/dist/watchers/evaluator.js

@@ -1,45 +0,0 @@
-import { execAsync } from '../tasks/scheduler.js';
-export async function evaluateWatcher(watcher) {
-    try {
-        const { stdout } = await execAsync(watcher.checkCommand, { timeout: 30000 });
-        const trimmed = stdout.trim();
-        const output = trimmed.length > 10240 ? trimmed.slice(0, 10240) + ' [truncated]' : trimmed;
-        const triggered = evaluateCondition(output, watcher.condition);
-        return { triggered, output };
-    }
-    catch (err) {
-        if (watcher.condition === 'error' || watcher.condition === 'any') {
-            return { triggered: true, output: `Check failed: ${err}` };
-        }
-        // Command failed but condition isn't 'error' — log warning, don't trigger
-        return { triggered: false, output: `Check failed: ${err}` };
-    }
-}
-function evaluateCondition(output, condition) {
-    if (condition.startsWith('contains '))
-        return output.includes(condition.slice(9).trim());
-    if (condition.startsWith('not contains '))
-        return !output.includes(condition.slice(13).trim());
-    if (condition.startsWith('> ')) {
-        const num = parseFloat(output);
-        const threshold = parseFloat(condition.slice(2));
-        if (Number.isNaN(num)) {
-            return true;
-        } // Can't parse = something's wrong = trigger
-        return num > threshold;
-    }
-    if (condition.startsWith('< ')) {
-        const num = parseFloat(output);
-        const threshold = parseFloat(condition.slice(2));
-        if (Number.isNaN(num)) {
-            return true;
-        }
-        return num < threshold;
-    }
-    if (condition === 'any')
-        return output.length > 0;
-    if (condition === 'error')
-        return false; // Only triggers on command failure (caught above)
-    // Default: check if output is non-empty and not "ok"
-    return output.length > 0 && output.toLowerCase() !== 'ok';
-}

package/dist/watchers/index.d.ts

@@ -1,4 +0,0 @@
-export { WatcherStore } from './store.js';
-export { WatcherScheduler } from './scheduler.js';
-export { evaluateWatcher } from './evaluator.js';
-export type { Watcher } from './types.js';

package/dist/watchers/index.js

@@ -1,3 +0,0 @@
-export { WatcherStore } from './store.js';
-export { WatcherScheduler } from './scheduler.js';
-export { evaluateWatcher } from './evaluator.js';

package/dist/watchers/scheduler.d.ts

@@ -1,20 +0,0 @@
-export declare class WatcherScheduler {
-    private store;
-    private nextCheckAt;
-    private running;
-    private stopping;
-    onNotify: ((text: string) => Promise<void>) | null;
-    /** Load all watchers from store and schedule them */
-    loadAndSchedule(): void;
-    /** Check for the reload signal file and reload if present */
-    checkForReload(): void;
-    /**
-     * Fire any watchers whose nextCheckAt has elapsed. Called every ~5s by the daemon
-     * poll loop. Sleep-resilient: after wake, the next tick catches all overdue checks.
-     */
-    tick(): void;
-    /** Stop the scheduler. In-flight runCheck promises detach and resolve naturally. */
-    stopAll(): void;
-    private runCheck;
-    private executeAction;
-}

package/dist/watchers/scheduler.js

@@ -1,183 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { WatcherStore } from './store.js';
-import { evaluateWatcher } from './evaluator.js';
-import { execAsync, intervalToMs } from '../tasks/scheduler.js';
-import { getLogsDir, getWatcherReloadSignalPath } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-import { PendingMessageStore } from '../session/pending-store.js';
-import { logActivity } from '../timeline/index.js';
-export class WatcherScheduler {
-    store = new WatcherStore();
-    // watcherId -> due time in ms epoch for next check
-    nextCheckAt = new Map();
-    // watcherIds with an in-flight runCheck
-    running = new Set();
-    stopping = false;
-    onNotify = null;
-    /** Load all watchers from store and schedule them */
-    loadAndSchedule() {
-        this.stopAll();
-        this.stopping = false;
-        const watchers = this.store.list();
-        let scheduled = 0;
-        for (const watcher of watchers) {
-            if (!watcher.enabled)
-                continue;
-            const ms = parseScheduleToMs(watcher.schedule);
-            if (!ms) {
-                logger.error(`Watcher: invalid schedule for "${watcher.name}": ${watcher.schedule}`);
-                continue;
-            }
-            // Seed nextCheckAt: if we have a lastCheckAt, fire `intervalMs` after it
-            // (catches up overdue checks after sleep/restart on the next tick).
-            // Otherwise wait `intervalMs` before first fire — matches today's setInterval semantics.
-            let due;
-            if (watcher.lastCheckAt) {
-                const last = new Date(watcher.lastCheckAt).getTime();
-                due = Number.isFinite(last) ? last + ms : Date.now() + ms;
-            }
-            else {
-                due = Date.now() + ms;
-            }
-            this.nextCheckAt.set(watcher.id, due);
-            scheduled++;
-        }
-        if (scheduled > 0 || watchers.length > 0) {
-            logger.info(`Watchers: loaded ${scheduled} active watchers (${watchers.length} total)`);
-        }
-    }
-    /** Check for the reload signal file and reload if present */
-    checkForReload() {
-        const signalPath = getWatcherReloadSignalPath();
-        if (fs.existsSync(signalPath)) {
-            try {
-                fs.unlinkSync(signalPath);
-            }
-            catch {
-                /* race condition, ok */
-            }
-            logger.info('Watchers: reload signal detected, reloading');
-            this.loadAndSchedule();
-        }
-    }
-    /**
-     * Fire any watchers whose nextCheckAt has elapsed. Called every ~5s by the daemon
-     * poll loop. Sleep-resilient: after wake, the next tick catches all overdue checks.
-     */
-    tick() {
-        if (this.stopping)
-            return;
-        const now = Date.now();
-        for (const [id, due] of [...this.nextCheckAt]) {
-            if (this.stopping)
-                return;
-            if (due > now)
-                continue;
-            if (this.running.has(id))
-                continue;
-            const watcher = this.store.get(id);
-            if (!watcher || !watcher.enabled) {
-                this.nextCheckAt.delete(id);
-                continue;
-            }
-            const intervalMs = parseScheduleToMs(watcher.schedule);
-            if (!intervalMs) {
-                this.nextCheckAt.delete(id);
-                continue;
-            }
-            // Advance BEFORE running — eliminates double-fire race
-            this.nextCheckAt.set(id, now + intervalMs);
-            this.running.add(id);
-            void this.runCheck(watcher).finally(() => this.running.delete(id));
-        }
-    }
-    /** Stop the scheduler. In-flight runCheck promises detach and resolve naturally. */
-    stopAll() {
-        this.stopping = true;
-        this.nextCheckAt.clear();
-    }
-    async runCheck(watcher) {
-        const logFile = path.join(getLogsDir(), `watcher-${watcher.name}.log`);
-        try {
-            const result = await evaluateWatcher(watcher);
-            this.store.markChecked(watcher.id);
-            if (result.triggered) {
-                this.store.markTriggered(watcher.id);
-                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] TRIGGERED: ${result.output.slice(0, 500)}\n`);
-                logActivity('watcher_triggered', `Watcher "${watcher.name}" triggered`, {
-                    details: result.output.slice(0, 500),
-                });
-                await this.executeAction(watcher, result.output);
-            }
-            else {
-                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] OK: ${result.output.slice(0, 200)}\n`);
-            }
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            logger.error(`Watcher "${watcher.name}" check failed:`, err);
-            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
-        }
-    }
-    async executeAction(watcher, output) {
-        switch (watcher.action) {
-            case 'notify':
-                if (this.onNotify) {
-                    await this.onNotify(`Watcher "${watcher.name}" triggered:\n${output.slice(0, 500)}`);
-                }
-                break;
-            case 'fix':
-                if (watcher.actionDetails) {
-                    try {
-                        await execAsync(watcher.actionDetails, { timeout: 60000 });
-                        if (this.onNotify) {
-                            await this.onNotify(`Watcher "${watcher.name}" triggered and auto-fixed:\n${output.slice(0, 300)}`);
-                        }
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        logger.error(`Watcher "${watcher.name}" fix command failed:`, err);
-                        if (this.onNotify) {
-                            await this.onNotify(`Watcher "${watcher.name}" triggered but fix failed: ${errMsg}`);
-                        }
-                    }
-                }
-                else {
-                    logger.warn(`Watcher "${watcher.name}" has action=fix but no actionDetails`);
-                }
-                break;
-            case 'delegate':
-                // Write to pending_messages for the daemon to pick up
-                if (watcher.actionDetails) {
-                    try {
-                        const { getDb } = await import('../db/index.js');
-                        const db = getDb();
-                        // actionDetails format: "tabName: message" or just a message for default tab
-                        const colonIdx = watcher.actionDetails.indexOf(':');
-                        let tabName = 'default';
-                        let message = watcher.actionDetails;
-                        if (colonIdx > 0 && colonIdx < 30) {
-                            tabName = watcher.actionDetails.slice(0, colonIdx).trim();
-                            message = watcher.actionDetails.slice(colonIdx + 1).trim();
-                        }
-                        const fullMessage = `[Watcher "${watcher.name}" triggered] ${message}\n\nWatcher output:\n${output.slice(0, 500)}`;
-                        PendingMessageStore.enqueueDelegation(tabName, fullMessage, db);
-                        if (this.onNotify) {
-                            await this.onNotify(`Watcher "${watcher.name}" triggered -- delegated to tab:${tabName}`);
-                        }
-                    }
-                    catch (err) {
-                        logger.error(`Watcher "${watcher.name}" delegation failed:`, err);
-                    }
-                }
-                break;
-        }
-    }
-}
-/** Parse schedule string like "every 5m", "every 1h", or raw interval "30m" to milliseconds */
-function parseScheduleToMs(schedule) {
-    // Strip "every " prefix if present
-    const raw = schedule.replace(/^every\s+/i, '');
-    return intervalToMs(raw);
-}

package/dist/watchers/store.d.ts

@@ -1,10 +0,0 @@
-import type { Watcher } from './types.js';
-export declare class WatcherStore {
-    list(): Watcher[];
-    get(id: string): Watcher | undefined;
-    create(watcher: Omit<Watcher, 'lastCheckAt' | 'lastTriggeredAt' | 'triggerCount' | 'enabled' | 'createdAt'>): void;
-    update(id: string, fields: Partial<Watcher>): boolean;
-    delete(id: string): boolean;
-    markChecked(id: string): void;
-    markTriggered(id: string): void;
-}

package/dist/watchers/store.js

@@ -1,56 +0,0 @@
-import { getDb } from '../db/index.js';
-function rowToWatcher(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        description: row.description,
-        checkCommand: row.check_command,
-        condition: row.condition,
-        action: row.action,
-        actionDetails: row.action_details,
-        schedule: row.schedule,
-        lastCheckAt: row.last_check_at,
-        lastTriggeredAt: row.last_triggered_at,
-        triggerCount: row.trigger_count,
-        enabled: row.enabled === 1,
-        createdAt: row.created_at,
-    };
-}
-export class WatcherStore {
-    list() {
-        const db = getDb();
-        return db.prepare('SELECT * FROM watchers ORDER BY created_at').all().map(rowToWatcher);
-    }
-    get(id) {
-        const db = getDb();
-        const row = db.prepare('SELECT * FROM watchers WHERE id = ?').get(id);
-        return row ? rowToWatcher(row) : undefined;
-    }
-    create(watcher) {
-        const db = getDb();
-        db.prepare(`INSERT INTO watchers (id, name, description, check_command, condition, action, action_details, schedule)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(watcher.id, watcher.name, watcher.description, watcher.checkCommand, watcher.condition, watcher.action, watcher.actionDetails, watcher.schedule);
-    }
-    update(id, fields) {
-        const db = getDb();
-        const existing = this.get(id);
-        if (!existing)
-            return false;
-        const merged = { ...existing, ...fields };
-        db.prepare(`UPDATE watchers SET name=?, description=?, check_command=?, condition=?, action=?, action_details=?, schedule=?, enabled=? WHERE id=?`).run(merged.name, merged.description, merged.checkCommand, merged.condition, merged.action, merged.actionDetails, merged.schedule, merged.enabled ? 1 : 0, id);
-        return true;
-    }
-    delete(id) {
-        const db = getDb();
-        const result = db.prepare('DELETE FROM watchers WHERE id = ?').run(id);
-        return result.changes > 0;
-    }
-    markChecked(id) {
-        const db = getDb();
-        db.prepare('UPDATE watchers SET last_check_at = ? WHERE id = ?').run(new Date().toISOString(), id);
-    }
-    markTriggered(id) {
-        const db = getDb();
-        db.prepare('UPDATE watchers SET last_triggered_at = ?, trigger_count = trigger_count + 1 WHERE id = ?').run(new Date().toISOString(), id);
-    }
-}

package/dist/watchers/types.d.ts

@@ -1,15 +0,0 @@
-export interface Watcher {
-    id: string;
-    name: string;
-    description: string | null;
-    checkCommand: string;
-    condition: string;
-    action: 'notify' | 'fix' | 'delegate';
-    actionDetails: string | null;
-    schedule: string;
-    lastCheckAt: string | null;
-    lastTriggeredAt: string | null;
-    triggerCount: number;
-    enabled: boolean;
-    createdAt: string;
-}

package/dist/watchers/types.js

@@ -1 +0,0 @@
-export {};

package/scripts/postinstall.mjs

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-// Beecork postinstall hook.
-//
-// Runs after `npm install -g beecork[@<version>]`. Goal: if a beecork daemon
-// is already managed by the OS (launchd plist on mac, systemd unit on linux)
-// from a DIFFERENT install path than this freshly-installed one, rewrite the
-// unit file to point at this install and signal the daemon to restart so the
-// running process picks up the new code without the user having to think about
-// install prefixes.
-//
-// No-ops cleanly in every other case (first install, local install,
-// dependency install, no daemon, dependency install in CI, etc.).
-
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import fs from 'node:fs';
-
-// Run only for global installs. npm sets npm_config_global="true" for `npm install -g`.
-// `npm ci` / `npm install` (no -g) inside the repo leaves it unset/empty — skip those.
-if (process.env.npm_config_global !== 'true') {
-  process.exit(0);
-}
-
-// Resolve the auto-heal module from dist/. If the user installed from a
-// tarball without dist/ (shouldn't happen — `files` whitelists dist/, and
-// `prepublishOnly` builds it — but be defensive), skip silently.
-const here = path.dirname(fileURLToPath(import.meta.url));
-const installRoot = path.dirname(here);
-const autoHealModule = path.join(installRoot, 'dist', 'util', 'auto-heal.js');
-
-if (!fs.existsSync(autoHealModule)) {
-  // Built artifacts missing — skip silently. This is the npm-publish-with-no-build
-  // edge case which is already caught by `prepublishOnly`. Don't fail the install.
-  process.exit(0);
-}
-
-try {
-  const { autoHealInstall } = await import(autoHealModule);
-  const result = autoHealInstall(import.meta.url);
-  if (result.action === 'rewrote-unit' || result.action === 'rewrote-and-signaled') {
-    process.stderr.write(`[beecork] launchd/systemd unit re-pointed at ${result.newDaemonScript}\n`);
-  }
-  if (result.action === 'signaled-daemon' || result.action === 'rewrote-and-signaled') {
-    process.stderr.write(`[beecork] running daemon signaled to restart on new code\n`);
-  }
-  // 'noop' / 'skip' → silent
-} catch (err) {
-  // Never fail an install on auto-heal trouble — just leave a breadcrumb.
-  process.stderr.write(`[beecork] postinstall auto-heal skipped: ${err?.message ?? err}\n`);
-}