beecork 1.4.11 → 1.5.0

package/dist/session/manager.js

@@ -2,24 +2,12 @@ import { v4 as uuidv4 } from 'uuid';
 import { ClaudeSubprocess } from './subprocess.js';
 import { CircuitBreaker } from './circuit-breaker.js';
 import { ContextMonitor } from './context-monitor.js';
+import { TabStore } from './tab-store.js';
 import { getDb } from '../db/index.js';
 import { resolveWorkingDir, validateTabName } from '../config.js';
 import { logger } from '../util/logger.js';
 import { logActivity } from '../timeline/index.js';
 import { getAllKnowledge, formatKnowledgeForContext } from '../knowledge/index.js';
-function rowToTab(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        sessionId: row.session_id,
-        status: row.status,
-        workingDir: row.working_dir,
-        createdAt: row.created_at,
-        lastActivityAt: row.last_activity_at,
-        pid: row.pid,
-        systemPrompt: row.system_prompt,
-    };
-}
 const MAX_QUEUE_SIZE = 10;
 let pendingPollCount = 0;
 export class TabManager {
@@ -88,17 +76,14 @@ export class TabManager {
     }
     /** Get all tabs from the database */
     listTabs() {
-        const db = getDb();
-        return db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC').all().map(rowToTab);
+        return TabStore.listAll();
     }
     /** Get a specific tab */
     getTab(tabName) {
-        const db = getDb();
-        return this.queryTab(db, tabName);
+        return TabStore.findByName(tabName);
     }
-    queryTab(db, tabName) {
-        const row = db.prepare('SELECT * FROM tabs WHERE name = ?').get(tabName);
-        return row ? rowToTab(row) : undefined;
+    queryTab(_db, tabName) {
+        return TabStore.findByName(tabName);
     }
     /** Stop a tab's running subprocess */
     stopTab(tabName) {
@@ -109,6 +94,15 @@ export class TabManager {
         this.updateTabStatus(tabName, 'stopped');
         this.clearQueue(tabName);
     }
+    /** Update a tab's system_prompt. Returns true if the tab existed. */
+    setSystemPrompt(tabName, systemPrompt) {
+        return TabStore.setSystemPrompt(tabName, systemPrompt);
+    }
+    /** Close a tab — stop subprocess and delete its rows. Returns true if the tab existed. */
+    closeTab(tabName) {
+        this.stopTab(tabName);
+        return TabStore.deleteWithMessages(tabName);
+    }
     /** Stop all running subprocesses (clean shutdown) */
     stopAll() {
         for (const [tabName, sub] of this.subprocesses) {
@@ -132,17 +126,24 @@ export class TabManager {
         const pending = db.prepare('SELECT * FROM pending_messages WHERE processed = 0 ORDER BY created_at ASC LIMIT 50').all();
         if (pending.length === 0)
             return;
+        const markProcessed = db.prepare('UPDATE pending_messages SET processed = 1 WHERE id = ?');
         for (const msg of pending) {
-            db.prepare('UPDATE pending_messages SET processed = 1 WHERE id = ?').run(msg.id);
+            // Mark processed AFTER delivery resolves (success OR failure) so a crash
+            // mid-loop doesn't leave the row both unprocessed in the DB and dropped
+            // from the in-memory iteration. Failures still mark processed — we don't
+            // want infinite retries — but the failure path also logs and notifies.
             if (msg.type === 'notification') {
-                // Route notifications to Telegram/WhatsApp via the notify callback
-                this.onNotify?.(msg.message).catch(err => logger.warn('Notify failed:', err));
+                this.onNotify?.(msg.message)
+                    .catch(err => logger.warn('Notify failed:', err))
+                    .finally(() => markProcessed.run(msg.id));
             }
             else {
-                // Route regular messages to tabs
-                this.sendMessage(msg.tab_name, msg.message).catch(err => {
+                this.sendMessage(msg.tab_name, msg.message)
+                    .catch(err => {
                     logger.error(`Failed to process pending message for tab ${msg.tab_name}:`, err);
-                });
+                    this.onNotify?.(`Pending message for tab "${msg.tab_name}" failed: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+                })
+                    .finally(() => markProcessed.run(msg.id));
             }
         }
     }
@@ -279,26 +280,31 @@ export class TabManager {
                     db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?')
                         .run('idle', new Date().toISOString(), tab.name);
                     logActivity('task_completed', 'Message processed', { tabName: tab.name, durationMs: result.durationMs, costUsd: result.costUsd, details: result.text.slice(0, 500) });
-                    // Context window compaction: if checkpoint was triggered, restart with summary
+                    // Context window compaction: if checkpoint was triggered, restart with summary.
                     const currentDepth = compactionDepth ?? 0;
                     if (checkpointTriggered && !result.error && result.text && currentDepth < 2) {
                         logger.info(`[${tab.name}] Compacting context (depth ${currentDepth + 1}/2) — requesting summary then restarting session`);
                         this.onNotify?.(`🔄 [${tab.name}] Context window full — compacting and continuing...`).catch(err => logger.warn('Notify failed:', err));
-                        // Ask Claude for a structured summary
-                        const summaryPrompt = 'Summarize your progress in this session concisely: completed steps, current state, remaining steps, and all important identifiers (file paths, URLs, variable names). Output ONLY the summary.';
-                        this.sendMessage(tab.name, summaryPrompt, { _compactionDepth: currentDepth + 1 }).then(summaryResult => {
-                            // Reset session: new session ID so next message starts fresh with summary context
-                            const newSessionId = uuidv4();
-                            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(newSessionId, tab.id);
-                            logger.info(`[${tab.name}] Context compacted — new session ${newSessionId.slice(0, 8)}...`);
-                            // Continue with original goal using the summary as in-prompt context (not persisted)
-                            const continuationPrompt = `[CONTEXT RESTORED FROM PREVIOUS SESSION]\n${summaryResult.text}\n\n[Continue the original task: "${enrichedPrompt.slice(0, 500)}"]`;
-                            this.sendMessage(tab.name, continuationPrompt, { onTextChunk, _compactionDepth: currentDepth + 1 }).then(resolve).catch(reject);
-                        }).catch(err => {
-                            logger.error(`[${tab.name}] Compaction failed:`, err);
-                            resolve(result); // Fall back to returning the original result
-                        });
-                        return; // Don't resolve yet — compaction flow will resolve
+                        // Async/await so any thrown error (from DB or sendMessage) routes through
+                        // a single catch instead of the previous nested .then().catch() chain
+                        // where a sync throw inside the inner .then could orphan the promise.
+                        (async () => {
+                            try {
+                                const summaryPrompt = 'Summarize your progress in this session concisely: completed steps, current state, remaining steps, and all important identifiers (file paths, URLs, variable names). Output ONLY the summary.';
+                                const summaryResult = await this.sendMessage(tab.name, summaryPrompt, { _compactionDepth: currentDepth + 1 });
+                                const newSessionId = uuidv4();
+                                db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(newSessionId, tab.id);
+                                logger.info(`[${tab.name}] Context compacted — new session ${newSessionId.slice(0, 8)}...`);
+                                const continuationPrompt = `[CONTEXT RESTORED FROM PREVIOUS SESSION]\n${summaryResult.text}\n\n[Continue the original task: "${enrichedPrompt.slice(0, 500)}"]`;
+                                const continuation = await this.sendMessage(tab.name, continuationPrompt, { onTextChunk, _compactionDepth: currentDepth + 1 });
+                                resolve(continuation);
+                            }
+                            catch (err) {
+                                logger.error(`[${tab.name}] Compaction failed:`, err);
+                                resolve(result); // Fall back to original result so the user gets *something*.
+                            }
+                        })();
+                        return; // Don't resolve here — the async compaction flow resolves.
                     }
                     // Check for delegation completion
                     import('../delegation/manager.js').then(({ completeDelegation }) => {

package/dist/session/subprocess.d.ts

@@ -12,6 +12,7 @@ export declare class ClaudeSubprocess {
     private proc;
     private buffer;
     private killTimer;
+    private runtimeTimer;
     readonly sessionId: string;
     constructor(tabName: string, workingDir: string, config: BeecorkConfig, sessionId?: string, tabSystemPrompt?: string | null | undefined);
     send(prompt: string, callbacks: SubprocessCallbacks, resume?: boolean): Promise<void>;

package/dist/session/subprocess.js

@@ -31,6 +31,7 @@ export class ClaudeSubprocess {
     proc = null;
     buffer = '';
     killTimer = null;
+    runtimeTimer = null;
     sessionId;
     constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
         this.tabName = tabName;
@@ -77,6 +78,10 @@ export class ClaudeSubprocess {
         });
         this.proc.on('error', (err) => {
             this.proc = null;
+            if (this.runtimeTimer) {
+                clearTimeout(this.runtimeTimer);
+                this.runtimeTimer = null;
+            }
             callbacks.onError(err);
         });
         this.proc.on('exit', (code) => {
@@ -85,9 +90,25 @@ export class ClaudeSubprocess {
                 clearTimeout(this.killTimer);
                 this.killTimer = null;
             }
+            if (this.runtimeTimer) {
+                clearTimeout(this.runtimeTimer);
+                this.runtimeTimer = null;
+            }
             logger.info(`[${this.tabName}] Claude subprocess exited (code: ${code})`);
             callbacks.onExit(code);
         });
+        // Hard runtime cap so a wedged claude can't pin a tab forever.
+        // Default 30 minutes. Disable by setting maxRuntimeMs to 0.
+        const maxRuntimeMs = this.config.claudeCode.maxRuntimeMs ?? 30 * 60 * 1000;
+        if (maxRuntimeMs > 0) {
+            this.runtimeTimer = setTimeout(() => {
+                if (!this.proc)
+                    return;
+                logger.warn(`[${this.tabName}] Subprocess exceeded maxRuntimeMs (${maxRuntimeMs}ms) — killing`);
+                callbacks.onError(new Error(`Subprocess timed out after ${Math.round(maxRuntimeMs / 1000)}s`));
+                this.kill();
+            }, maxRuntimeMs);
+        }
     }
     kill() {
         if (!this.proc)

package/dist/session/tab-store.d.ts

@@ -0,0 +1,28 @@
+import type Database from 'better-sqlite3';
+import type { Tab, TabStatus } from '../types.js';
+/**
+ * SQL helpers for the `tabs` table. Single place for any code that needs to
+ * read/write tab rows. TabManager owns subprocess lifecycle; TabStore owns
+ * the schema knowledge.
+ *
+ * All methods accept an optional `db` param so they're testable against an
+ * in-memory database. The no-arg form uses the singleton.
+ */
+export declare const TabStore: {
+    listAll(db?: Database.Database): Tab[];
+    findByName(name: string, db?: Database.Database): Tab | undefined;
+    getIdByName(name: string, db?: Database.Database): string | undefined;
+    countAll(db?: Database.Database): number;
+    countRunning(db?: Database.Database): number;
+    /** All tabs marked 'running' — used by daemon crash-recovery on startup. */
+    findRunning(db?: Database.Database): Tab[];
+    /** Most-recently-active tab — used by MCP to surface "current" context. */
+    mostRecent(db?: Database.Database): Tab | undefined;
+    setStatus(name: string, status: TabStatus, db?: Database.Database): void;
+    setIdleById(id: string, db?: Database.Database): void;
+    /** Used by MCP close-tab to nudge daemon recovery loop. */
+    markRunningAsStopped(name: string, db?: Database.Database): void;
+    setSystemPrompt(name: string, systemPrompt: string, db?: Database.Database): boolean;
+    /** Delete a tab and all of its messages atomically. Returns true if it existed. */
+    deleteWithMessages(name: string, db?: Database.Database): boolean;
+};

package/dist/session/tab-store.js

@@ -0,0 +1,77 @@
+import { getDb } from '../db/index.js';
+function rowToTab(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        sessionId: row.session_id,
+        status: row.status,
+        workingDir: row.working_dir,
+        createdAt: row.created_at,
+        lastActivityAt: row.last_activity_at,
+        pid: row.pid,
+        systemPrompt: row.system_prompt,
+    };
+}
+/**
+ * SQL helpers for the `tabs` table. Single place for any code that needs to
+ * read/write tab rows. TabManager owns subprocess lifecycle; TabStore owns
+ * the schema knowledge.
+ *
+ * All methods accept an optional `db` param so they're testable against an
+ * in-memory database. The no-arg form uses the singleton.
+ */
+export const TabStore = {
+    listAll(db = getDb()) {
+        return db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC').all().map(rowToTab);
+    },
+    findByName(name, db = getDb()) {
+        const row = db.prepare('SELECT * FROM tabs WHERE name = ?').get(name);
+        return row ? rowToTab(row) : undefined;
+    },
+    getIdByName(name, db = getDb()) {
+        const row = db.prepare('SELECT id FROM tabs WHERE name = ?').get(name);
+        return row?.id;
+    },
+    countAll(db = getDb()) {
+        return db.prepare('SELECT COUNT(*) as c FROM tabs').get().c;
+    },
+    countRunning(db = getDb()) {
+        return db.prepare("SELECT COUNT(*) as c FROM tabs WHERE status = 'running'").get().c;
+    },
+    /** All tabs marked 'running' — used by daemon crash-recovery on startup. */
+    findRunning(db = getDb()) {
+        return db.prepare("SELECT * FROM tabs WHERE status = 'running'").all().map(rowToTab);
+    },
+    /** Most-recently-active tab — used by MCP to surface "current" context. */
+    mostRecent(db = getDb()) {
+        const row = db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC LIMIT 1').get();
+        return row ? rowToTab(row) : undefined;
+    },
+    setStatus(name, status, db = getDb()) {
+        db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?')
+            .run(status, new Date().toISOString(), name);
+    },
+    setIdleById(id, db = getDb()) {
+        db.prepare("UPDATE tabs SET status = 'idle', pid = NULL WHERE id = ?").run(id);
+    },
+    /** Used by MCP close-tab to nudge daemon recovery loop. */
+    markRunningAsStopped(name, db = getDb()) {
+        db.prepare("UPDATE tabs SET status = 'stopped', pid = NULL WHERE name = ? AND status = 'running'").run(name);
+    },
+    setSystemPrompt(name, systemPrompt, db = getDb()) {
+        const result = db.prepare('UPDATE tabs SET system_prompt = ? WHERE name = ?').run(systemPrompt, name);
+        return result.changes > 0;
+    },
+    /** Delete a tab and all of its messages atomically. Returns true if it existed. */
+    deleteWithMessages(name, db = getDb()) {
+        const id = this.getIdByName(name, db);
+        if (!id)
+            return false;
+        const tx = db.transaction(() => {
+            db.prepare('DELETE FROM messages WHERE tab_id = ?').run(id);
+            db.prepare('DELETE FROM tabs WHERE id = ?').run(id);
+        });
+        tx();
+        return true;
+    },
+};

package/dist/tasks/scheduler.d.ts

@@ -30,3 +30,9 @@ export declare class TaskScheduler {
 export declare function intervalToMs(interval: string): number | null;
 /** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
 export declare function intervalToCron(interval: string): string | null;
+/**
+ * Validate a schedule string for a given scheduleType. Returns an error string
+ * on invalid input or null when valid. Used by MCP + dashboard before insert
+ * so misconfigured tasks fail loud instead of silently never firing.
+ */
+export declare function validateSchedule(scheduleType: string, schedule: string): string | null;

package/dist/tasks/scheduler.js

@@ -207,28 +207,33 @@ export class TaskScheduler {
         }
     }
 }
-/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
-export function intervalToMs(interval) {
+/** Parse a "1w2d3h45m"-style interval into its parts. Returns null on invalid input. */
+function parseInterval(interval) {
     const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
     if (!match || match.slice(1).every(g => g === undefined))
         return null;
-    const weeks = parseInt(match[1] || '0', 10);
-    const days = parseInt(match[2] || '0', 10);
-    const hours = parseInt(match[3] || '0', 10);
-    const mins = parseInt(match[4] || '0', 10);
+    return {
+        weeks: parseInt(match[1] || '0', 10),
+        days: parseInt(match[2] || '0', 10),
+        hours: parseInt(match[3] || '0', 10),
+        mins: parseInt(match[4] || '0', 10),
+    };
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
+export function intervalToMs(interval) {
+    const parts = parseInterval(interval);
+    if (!parts)
+        return null;
+    const { weeks, days, hours, mins } = parts;
     const totalMs = ((weeks * 7 * 24 * 60) + (days * 24 * 60) + (hours * 60) + mins) * 60 * 1000;
     return totalMs > 0 ? totalMs : null;
 }
 /** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
 export function intervalToCron(interval) {
-    // Try combined format: 1h30m, 2h, 30m, 1d, 2w
-    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
-    if (!match || match.slice(1).every(g => g === undefined))
+    const parts = parseInterval(interval);
+    if (!parts)
         return null;
-    const weeks = parseInt(match[1] || '0', 10);
-    const days = parseInt(match[2] || '0', 10);
-    const hours = parseInt(match[3] || '0', 10);
-    const mins = parseInt(match[4] || '0', 10);
+    const { weeks, days, hours, mins } = parts;
     // Convert to total minutes for simple intervals
     const totalMins = weeks * 7 * 24 * 60 + days * 24 * 60 + hours * 60 + mins;
     if (totalMins <= 0)
@@ -248,3 +253,37 @@ export function intervalToCron(interval) {
     // Combined or large intervals -- return null, handled by intervalToMs fallback
     return null;
 }
+/**
+ * Validate a schedule string for a given scheduleType. Returns an error string
+ * on invalid input or null when valid. Used by MCP + dashboard before insert
+ * so misconfigured tasks fail loud instead of silently never firing.
+ */
+export function validateSchedule(scheduleType, schedule) {
+    if (!schedule)
+        return 'schedule is required';
+    switch (scheduleType) {
+        case 'at': {
+            const ts = Date.parse(schedule);
+            if (Number.isNaN(ts))
+                return `"${schedule}" is not a valid ISO datetime`;
+            return null;
+        }
+        case 'every': {
+            if (intervalToMs(schedule) === null) {
+                return `"${schedule}" is not a valid interval. Use formats like "30m", "2h", "1d", "1h30m".`;
+            }
+            return null;
+        }
+        case 'cron': {
+            try {
+                CronExpressionParser.parse(schedule);
+                return null;
+            }
+            catch (err) {
+                return `"${schedule}" is not a valid cron expression: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        }
+        default:
+            return `unknown scheduleType "${scheduleType}"`;
+    }
+}

package/dist/tasks/store.js

@@ -18,7 +18,7 @@ export class TaskStore {
     }
     list() {
         const db = getDb();
-        return db.prepare('SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at').all('local').map(rowToTask);
+        return db.prepare('SELECT * FROM tasks ORDER BY created_at').all().map(rowToTask);
     }
     get(id) {
         const db = getDb();
@@ -27,8 +27,8 @@ export class TaskStore {
     }
     add(job) {
         const db = getDb();
-        db.prepare(`INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, user_id, created_at, last_run_at, next_run_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(job.id, job.name, job.scheduleType, job.schedule, job.tabName, job.message, job.payloadType || 'agentTurn', job.enabled ? 1 : 0, 'local', job.createdAt, job.lastRunAt, job.nextRunAt);
+        db.prepare(`INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, created_at, last_run_at, next_run_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(job.id, job.name, job.scheduleType, job.schedule, job.tabName, job.message, job.payloadType || 'agentTurn', job.enabled ? 1 : 0, job.createdAt, job.lastRunAt, job.nextRunAt);
     }
     update(id, updates) {
         const db = getDb();
@@ -71,11 +71,11 @@ export class TaskStore {
             const jobs = data.jobs || [];
             if (jobs.length === 0)
                 return;
-            const insert = db.prepare(`INSERT OR IGNORE INTO tasks (id, name, schedule_type, schedule, tab_name, message, enabled, user_id, created_at, last_run_at, next_run_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const insert = db.prepare(`INSERT OR IGNORE INTO tasks (id, name, schedule_type, schedule, tab_name, message, enabled, created_at, last_run_at, next_run_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
             const tx = db.transaction(() => {
                 for (const j of jobs) {
-                    insert.run(j.id, j.name, j.scheduleType, j.schedule, j.tabName || 'default', j.message, j.enabled ? 1 : 0, 'local', j.createdAt, j.lastRunAt, j.nextRunAt);
+                    insert.run(j.id, j.name, j.scheduleType, j.schedule, j.tabName || 'default', j.message, j.enabled ? 1 : 0, j.createdAt, j.lastRunAt, j.nextRunAt);
                 }
             });
             tx();

package/dist/timeline/query.js

@@ -12,8 +12,12 @@ export function getTimeline(options) {
     const conditions = [];
     const params = [];
     if (options?.date) {
-        conditions.push('date(created_at) = ?');
-        params.push(options.date);
+        // Sargable range so idx_activity_log_created can serve the query.
+        // `date(created_at) = ?` is non-sargable and forces a full scan.
+        const dayStart = `${options.date} 00:00:00`;
+        const dayEnd = `${options.date} 23:59:59.999`;
+        conditions.push('created_at >= ? AND created_at <= ?');
+        params.push(dayStart, dayEnd);
     }
     if (options?.tabName) {
         conditions.push('tab_name = ?');

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface ClaudeCodeConfig {
     defaultFlags: string[];
     maxBudgetUsd?: number;
     computerUse?: boolean;
+    /** Hard timeout per subprocess turn. Default 30 min. Set to 0 to disable. */
+    maxRuntimeMs?: number;
 }
 export interface MemoryConfig {
     dbPath: string;
@@ -25,6 +27,8 @@ export interface WhatsAppConfig {
     mode: 'baileys';
     sessionPath: string;
     allowedNumbers: string[];
+    /** Optional admin phone number. Defaults to allowedNumbers[0]. */
+    adminNumber?: string;
 }
 export interface VoiceConfig {
     sttProvider: 'whisper-api' | 'none';
@@ -37,6 +41,8 @@ export interface VoiceConfig {
 export interface DiscordConfig {
     token: string;
     allowedUserIds?: string[];
+    /** Optional admin user ID. Defaults to allowedUserIds[0]. */
+    adminUserId?: string;
 }
 export interface WebhookConfig {
     enabled: boolean;
@@ -65,6 +71,15 @@ export interface MediaGeneratorConfig {
     model?: string;
     style?: string;
 }
+/** A media file attached to a message. Shared by channels + util/text + media. */
+export interface MediaAttachment {
+    type: 'image' | 'audio' | 'video' | 'document' | 'voice';
+    mimeType: string;
+    filePath: string;
+    fileName?: string;
+    duration?: number;
+    caption?: string;
+}
 export interface BeecorkConfig {
     telegram: TelegramConfig;
     whatsapp?: WhatsAppConfig;

package/dist/util/paths.d.ts

@@ -7,5 +7,6 @@ export declare function getLogsDir(): string;
 export declare function getPidPath(): string;
 export declare function getRuntimeInfoPath(): string;
 export declare function getCronReloadSignalPath(): string;
+export declare function getWatcherReloadSignalPath(): string;
 export declare function ensureBeecorkDirs(): void;
 export declare function expandHome(p: string): string;

package/dist/util/paths.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import fs from 'node:fs';
 const BEECORK_DIR = '.beecork';
 export function getBeecorkHome() {
-    return path.join(os.homedir(), BEECORK_DIR);
+    return process.env.BEECORK_HOME || path.join(os.homedir(), BEECORK_DIR);
 }
 export function getConfigPath() {
     return path.join(getBeecorkHome(), 'config.json');
@@ -29,6 +29,9 @@ export function getRuntimeInfoPath() {
 export function getCronReloadSignalPath() {
     return path.join(getBeecorkHome(), '.cron-reload');
 }
+export function getWatcherReloadSignalPath() {
+    return path.join(getBeecorkHome(), '.watcher-reload');
+}
 export function ensureBeecorkDirs() {
     const home = getBeecorkHome();
     fs.mkdirSync(home, { recursive: true });

package/dist/util/rate-limiter.js

@@ -21,6 +21,14 @@ export class RateLimiter {
             logger.warn(`Rate limit: global limit reached (${this.globalLimit}/min)`);
             return false;
         }
+        // Bound the per-key map so a daemon that has seen many one-off keys
+        // (e.g. thousands of Telegram groups over months) doesn't leak memory.
+        if (this.perKey.size > 1000) {
+            for (const [k, w] of this.perKey) {
+                if (now > w.resetAt)
+                    this.perKey.delete(k);
+            }
+        }
         // Reset per-key window
         let keyWindow = this.perKey.get(key);
         if (!keyWindow || now > keyWindow.resetAt) {

package/dist/util/text.d.ts

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

package/dist/util/text.js

@@ -1,4 +1,18 @@
-const DEFAULT_MAX_LENGTH = 4096;
+/**
+ * Shared message-size limits. Single source of truth so caps don't drift
+ * between channels, MCP, and dashboard.
+ */
+export const MESSAGE_LIMITS = {
+    /** Per-chunk send size (Telegram = 4096; other channels chunk to this too). */
+    CHUNK: 4096,
+    /** HTTP request body cap (webhook + dashboard endpoints). */
+    HTTP_BODY: 1024 * 1024, // 1 MB
+    /** Webhook channel single-message payload. */
+    WEBHOOK_PROMPT: 100_000, // 100 KB
+    /** MCP tool content/message field. Tight because it goes through Claude's tool-result token budget. */
+    MCP_CONTENT: 10_240, // 10 KB
+};
+const DEFAULT_MAX_LENGTH = MESSAGE_LIMITS.CHUNK;
 /** Split long text into chunks that fit within a message limit */
 export function chunkText(text, maxLength = DEFAULT_MAX_LENGTH) {
     if (text.length <= maxLength)
@@ -50,6 +64,16 @@ export function parseTabMessage(text) {
     }
     return { tabName: 'default', prompt: text };
 }
+/**
+ * Build the channel-side message text with an optional [tabName] prefix.
+ * Used by all three channels' sendResponse paths so the prefix format is
+ * consistent and the gate logic (skip "default", skip empty) lives in one place.
+ */
+export function formatTabbedResponse(text, tabName) {
+    if (!tabName || tabName === 'default')
+        return text;
+    return `[${tabName}] ${text}`;
+}
 /** Build prompt text from media attachments */
 export function buildMediaPrompt(media, textPrompt) {
     if (media.length === 0)

package/dist/watchers/scheduler.js

@@ -3,9 +3,8 @@ import path from 'node:path';
 import { WatcherStore } from './store.js';
 import { evaluateWatcher } from './evaluator.js';
 import { execAsync, intervalToMs } from '../tasks/scheduler.js';
-import { getBeecorkHome, getLogsDir } from '../util/paths.js';
+import { getLogsDir, getWatcherReloadSignalPath } from '../util/paths.js';
 import { logger } from '../util/logger.js';
-const WATCHER_RELOAD_SIGNAL_NAME = '.watcher-reload';
 export class WatcherScheduler {
     store = new WatcherStore();
     // watcherId -> due time in ms epoch for next check
@@ -48,7 +47,7 @@ export class WatcherScheduler {
     }
     /** Check for the reload signal file and reload if present */
     checkForReload() {
-        const signalPath = path.join(getBeecorkHome(), WATCHER_RELOAD_SIGNAL_NAME);
+        const signalPath = getWatcherReloadSignalPath();
         if (fs.existsSync(signalPath)) {
             try {
                 fs.unlinkSync(signalPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.4.11",
+  "version": "1.5.0",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {

package/dist/users/index.d.ts

@@ -1,2 +0,0 @@
-export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';
-export type { User } from './service.js';

package/dist/users/index.js

@@ -1 +0,0 @@
-export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';