beecork 1.4.9 → 1.4.11

package/dist/daemon.js

@@ -12,6 +12,7 @@ import { cleanupMedia } from './media/store.js';
 import { createNotificationProvider } from './notifications/index.js';
 import { VERSION } from './version.js';
 import { logActivity } from './timeline/index.js';
+import { findInstallRoot, getDaemonScript, writeRuntimeInfo, removeRuntimeInfo } from './util/install-info.js';
 let tabManager;
 let channelRegistry;
 let taskScheduler;
@@ -71,6 +72,21 @@ async function main() {
         fs.writeFileSync(pidPath, String(process.pid));
     }
     logger.info(`PID file written: ${process.pid}`);
+    // 3a. Write runtime.json so the CLI / postinstall can detect install-path divergence
+    try {
+        const installRoot = findInstallRoot(import.meta.url);
+        writeRuntimeInfo({
+            pid: process.pid,
+            version: VERSION,
+            installRoot,
+            daemonScript: getDaemonScript(installRoot),
+            startedAt: new Date().toISOString(),
+            nodeVersion: process.version,
+        });
+    }
+    catch (err) {
+        logger.warn('Could not write runtime.json (auto-heal may be skipped):', err);
+    }
     // 4. Create TabManager
     tabManager = new TabManager(config);
     // 5. Ensure default tab
@@ -188,6 +204,7 @@ async function main() {
         const pidPath = getPidPath();
         if (fs.existsSync(pidPath))
             fs.unlinkSync(pidPath);
+        removeRuntimeInfo();
         logActivity('system_event', 'Beecork daemon stopped');
         logger.info('Beecork daemon stopped.');
         logger.close();

package/dist/index.js

@@ -3,6 +3,18 @@ import { Command } from 'commander';
 import { platform } from 'node:os';
 import { VERSION } from './version.js';
 import { setupWizard } from './cli/setup.js';
+import { autoHealInstall } from './util/auto-heal.js';
+// Auto-heal install-path divergence: if the daemon is running from a different
+// beecork install than this CLI binary (e.g. user did `npm install -g beecork@latest`
+// to a different prefix than the launchd plist points at), rewrite the unit file
+// and signal the daemon to restart. Idempotent no-op otherwise. Never blocks the CLI.
+{
+    const heal = autoHealInstall(import.meta.url);
+    if (heal.action !== 'noop' && heal.action !== 'skip') {
+        const target = heal.newDaemonScript ?? '(running daemon)';
+        process.stderr.write(`[beecork] auto-heal: ${heal.action} → ${target}\n`);
+    }
+}
 import { startDaemon, stopDaemon, showStatus, listTabs, tailLogs, listCrons, deleteCron, listMemories, deleteMemory, sendMessage, updateBeecork, } from './cli/commands.js';
 const program = new Command();
 program

package/dist/observability/analytics.d.ts

@@ -1,3 +1,4 @@
+import type Database from 'better-sqlite3';
 export interface CostSummary {
     today: number;
     last7Days: number;
@@ -19,6 +20,11 @@ export interface ActivitySummary {
 }
 export declare function getCostSummary(): CostSummary;
 export declare function getActivitySummary(hours?: number): ActivitySummary;
+/**
+ * Returns a notification only on state transitions (ok↔breach), persisting
+ * the state in the `preferences` table so daemon restarts don't re-fire.
+ */
+export declare function checkAnomaliesWithDb(db: Database.Database): string | null;
 export declare function checkAnomalies(): string | null;
 export declare function formatCostSummary(summary: CostSummary): string;
 export declare function formatActivitySummary(summary: ActivitySummary): string;

package/dist/observability/analytics.js

@@ -30,8 +30,12 @@ export function getActivitySummary(hours = 24) {
         activeTabsCount,
     };
 }
-export function checkAnomalies() {
-    const db = getDb();
+const ANOMALY_STATE_KEY = 'anomaly_spend_state';
+/**
+ * Returns a notification only on state transitions (ok↔breach), persisting
+ * the state in the `preferences` table so daemon restarts don't re-fire.
+ */
+export function checkAnomaliesWithDb(db) {
     // Today's spend
     const todaySpend = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')").get().total;
     // 7-day rolling average (excluding today)
@@ -43,10 +47,21 @@ export function checkAnomalies() {
       GROUP BY date(created_at)
     )
   `).get().avg;
-    if (avgSpend > 0 && todaySpend > avgSpend * 2) {
+    const isBreach = avgSpend > 0 && todaySpend > avgSpend * 2;
+    const newState = isBreach ? 'breach' : 'ok';
+    const prevRow = db.prepare('SELECT value FROM preferences WHERE key = ?').get(ANOMALY_STATE_KEY);
+    const prevState = prevRow?.value ?? 'ok';
+    if (newState === prevState)
+        return null;
+    db.prepare(`INSERT INTO preferences (key, value, updated_at) VALUES (?, ?, datetime('now'))
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')`).run(ANOMALY_STATE_KEY, newState);
+    if (isBreach) {
         return `⚠️ Anomaly: Today's spend ($${todaySpend.toFixed(4)}) exceeds 2x your 7-day average ($${avgSpend.toFixed(4)}/day)`;
     }
-    return null;
+    return `✅ Recovered: Today's spend ($${todaySpend.toFixed(4)}) is back within 2x your 7-day average ($${avgSpend.toFixed(4)}/day)`;
+}
+export function checkAnomalies() {
+    return checkAnomaliesWithDb(getDb());
 }
 export function formatCostSummary(summary) {
     const lines = [

package/dist/util/auto-heal.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Auto-heal install-path divergence between the CLI (this process) and the
+ * running daemon. Triggered both from the npm postinstall hook and from the
+ * CLI entry on every invocation — both paths converge here so the policy is
+ * single-sourced and idempotent.
+ *
+ * What "divergence" means:
+ *   The daemon's launchd plist (or systemd unit) hard-codes an absolute path
+ *   to dist/daemon.js. If `npm install -g beecork@<new>` lands in a different
+ *   npm prefix than the one the unit file points at, the daemon keeps running
+ *   the old code while the CLI shows the new version. Bug reports get
+ *   misdiagnosed because the user thinks both are on the new version.
+ *
+ * What this function does:
+ *   1. Rewrite the unit file's daemon path if it doesn't point at us.
+ *   2. SIGTERM the running daemon (KeepAlive / Restart=always brings it back
+ *      on the new code) only when its runtime.json shows it was launched from
+ *      a different install root than ours.
+ *
+ * Returns a Result describing what happened, for the caller to surface (or not)
+ * to the user. The auto-heal NEVER throws — failures degrade to {action:'skip'}.
+ */
+export interface HealResult {
+    action: 'noop' | 'rewrote-unit' | 'signaled-daemon' | 'rewrote-and-signaled' | 'skip';
+    reason?: string;
+    unitPath?: string;
+    oldDaemonScript?: string;
+    newDaemonScript?: string;
+}
+export declare function autoHealInstall(fromFileUrl: string): HealResult;
+/**
+ * Extract the daemon-script absolute path from a launchd plist or systemd unit.
+ * Returns null if the file shape isn't recognized — caller treats that as "skip".
+ *
+ * launchd: looks inside <key>ProgramArguments</key><array> for the .js entry.
+ * systemd: looks for ExecStart=<node> <daemon.js> on a single line.
+ */
+export declare function extractDaemonScript(content: string): string | null;
+/** Rewrite-only variant used by tests and the postinstall hook in dry-run mode. */
+export declare function rewriteUnitDaemonScript(unitPath: string, newDaemonScript: string): {
+    rewrote: boolean;
+    oldDaemonScript: string | null;
+};

package/dist/util/auto-heal.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import { findInstallRoot, getDaemonScript, readRuntimeInfo, isPidAlive, getServiceUnitPath, } from './install-info.js';
+export function autoHealInstall(fromFileUrl) {
+    try {
+        const currentRoot = findInstallRoot(fromFileUrl);
+        const currentDaemonScript = getDaemonScript(currentRoot);
+        const unitPath = getServiceUnitPath();
+        if (!unitPath || !fs.existsSync(unitPath)) {
+            // No installed service — beecork has been npm-installed but `beecork setup` (or
+            // equivalent) hasn't been run yet. Nothing to heal.
+            return { action: 'skip', reason: 'no service unit file present' };
+        }
+        const unitContent = fs.readFileSync(unitPath, 'utf-8');
+        const oldDaemonScript = extractDaemonScript(unitContent);
+        let rewroteUnit = false;
+        if (oldDaemonScript && oldDaemonScript !== currentDaemonScript) {
+            // Validate the new path actually exists before rewriting — never break the daemon
+            // by pointing it at a missing file.
+            if (!fs.existsSync(currentDaemonScript)) {
+                return { action: 'skip', reason: `current install missing daemon: ${currentDaemonScript}` };
+            }
+            const next = unitContent.split(oldDaemonScript).join(currentDaemonScript);
+            const tmp = unitPath + '.tmp';
+            fs.writeFileSync(tmp, next);
+            fs.renameSync(tmp, unitPath);
+            rewroteUnit = true;
+        }
+        // Restart the daemon if it's currently running from a stale install. This is
+        // separate from the unit-file rewrite so we also catch the case where the unit
+        // file is already current but the running process predates the latest install.
+        const runtime = readRuntimeInfo();
+        let signaledDaemon = false;
+        if (runtime && runtime.installRoot !== currentRoot && isPidAlive(runtime.pid)) {
+            try {
+                process.kill(runtime.pid, 'SIGTERM');
+                signaledDaemon = true;
+            }
+            catch {
+                // Permission denied (different user, or already gone). Surface as skip;
+                // we still rewrote the unit file so the next start picks up the new path.
+            }
+        }
+        if (rewroteUnit && signaledDaemon) {
+            return { action: 'rewrote-and-signaled', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+        }
+        if (rewroteUnit)
+            return { action: 'rewrote-unit', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+        if (signaledDaemon)
+            return { action: 'signaled-daemon', unitPath };
+        return { action: 'noop' };
+    }
+    catch (err) {
+        return { action: 'skip', reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Extract the daemon-script absolute path from a launchd plist or systemd unit.
+ * Returns null if the file shape isn't recognized — caller treats that as "skip".
+ *
+ * launchd: looks inside <key>ProgramArguments</key><array> for the .js entry.
+ * systemd: looks for ExecStart=<node> <daemon.js> on a single line.
+ */
+export function extractDaemonScript(content) {
+    // launchd plist: pull the second <string> inside ProgramArguments
+    const launchdMatch = content.match(/<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/);
+    if (launchdMatch) {
+        const args = Array.from(launchdMatch[1].matchAll(/<string>([^<]+)<\/string>/g)).map(m => m[1]);
+        const jsArg = args.find(a => a.endsWith('daemon.js'));
+        if (jsArg)
+            return jsArg;
+    }
+    // systemd unit: ExecStart=<node> <daemon.js> [args...]
+    const systemdMatch = content.match(/^ExecStart\s*=\s*(.+)$/m);
+    if (systemdMatch) {
+        const parts = systemdMatch[1].split(/\s+/);
+        const jsArg = parts.find(p => p.endsWith('daemon.js'));
+        if (jsArg)
+            return jsArg;
+    }
+    return null;
+}
+/** Rewrite-only variant used by tests and the postinstall hook in dry-run mode. */
+export function rewriteUnitDaemonScript(unitPath, newDaemonScript) {
+    if (!fs.existsSync(unitPath))
+        return { rewrote: false, oldDaemonScript: null };
+    const content = fs.readFileSync(unitPath, 'utf-8');
+    const oldDaemonScript = extractDaemonScript(content);
+    if (!oldDaemonScript)
+        return { rewrote: false, oldDaemonScript: null };
+    if (oldDaemonScript === newDaemonScript)
+        return { rewrote: false, oldDaemonScript };
+    const next = content.split(oldDaemonScript).join(newDaemonScript);
+    const tmp = unitPath + '.tmp';
+    fs.writeFileSync(tmp, next);
+    fs.renameSync(tmp, unitPath);
+    return { rewrote: true, oldDaemonScript };
+}

package/dist/util/install-info.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Metadata the daemon writes to ~/.beecork/runtime.json at startup so the CLI
+ * (and postinstall hook) can detect when daemon and CLI are running from
+ * different physical installs of beecork — the most common silent-staleness
+ * mode after `npm install -g beecork@<new>` lands in a prefix the daemon's
+ * launchd plist doesn't point at.
+ */
+export interface RuntimeInfo {
+    pid: number;
+    version: string;
+    /** The package root: <prefix>/lib/node_modules/beecork. Single canonical key. */
+    installRoot: string;
+    /** Absolute path to dist/daemon.js — derived from installRoot. */
+    daemonScript: string;
+    /** ISO timestamp. */
+    startedAt: string;
+    /** process.version (e.g. "v20.11.0") */
+    nodeVersion: string;
+}
+/**
+ * Walk up from a given file (typically import.meta.url) to find the directory
+ * containing package.json — i.e. the beecork install root. Works for both:
+ *  - source dev runs (.../src/util/install-info.ts → .../ )
+ *  - built/installed runs (.../dist/util/install-info.js → .../ )
+ */
+export declare function findInstallRoot(fromFileUrl: string): string;
+export declare function getDaemonScript(installRoot: string): string;
+export declare function writeRuntimeInfo(info: RuntimeInfo): void;
+export declare function readRuntimeInfo(): RuntimeInfo | null;
+export declare function removeRuntimeInfo(): void;
+export declare function isPidAlive(pid: number): boolean;
+/**
+ * Cross-platform path to the service-manager unit file that launches the daemon.
+ * Returns null if beecork doesn't manage one on this OS (currently Windows uses
+ * Task Scheduler and is out of scope for the auto-heal flow).
+ */
+export declare function getServiceUnitPath(): string | null;

package/dist/util/install-info.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { getRuntimeInfoPath } from './paths.js';
+/**
+ * Walk up from a given file (typically import.meta.url) to find the directory
+ * containing package.json — i.e. the beecork install root. Works for both:
+ *  - source dev runs (.../src/util/install-info.ts → .../ )
+ *  - built/installed runs (.../dist/util/install-info.js → .../ )
+ */
+export function findInstallRoot(fromFileUrl) {
+    const fromPath = fileURLToPath(fromFileUrl);
+    let dir = path.dirname(fromPath);
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`Could not locate beecork install root walking up from ${fromPath}`);
+}
+export function getDaemonScript(installRoot) {
+    return path.join(installRoot, 'dist', 'daemon.js');
+}
+export function writeRuntimeInfo(info) {
+    const filePath = getRuntimeInfoPath();
+    // Atomic-ish write: temp + rename so a partial write never confuses a reader.
+    const tmp = filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(info, null, 2));
+    fs.renameSync(tmp, filePath);
+}
+export function readRuntimeInfo() {
+    const filePath = getRuntimeInfoPath();
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (typeof data?.pid === 'number' && typeof data?.installRoot === 'string') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function removeRuntimeInfo() {
+    const filePath = getRuntimeInfoPath();
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { /* not present, fine */ }
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Cross-platform path to the service-manager unit file that launches the daemon.
+ * Returns null if beecork doesn't manage one on this OS (currently Windows uses
+ * Task Scheduler and is out of scope for the auto-heal flow).
+ */
+export function getServiceUnitPath() {
+    const home = os.homedir();
+    if (process.platform === 'darwin')
+        return path.join(home, 'Library', 'LaunchAgents', 'com.beecork.daemon.plist');
+    if (process.platform === 'linux')
+        return path.join(home, '.config', 'systemd', 'user', 'beecork.service');
+    return null;
+}

package/dist/util/paths.d.ts

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

package/dist/util/paths.js

@@ -23,6 +23,9 @@ export function getLogsDir() {
 export function getPidPath() {
     return path.join(getBeecorkHome(), 'beecork.pid');
 }
+export function getRuntimeInfoPath() {
+    return path.join(getBeecorkHome(), 'runtime.json');
+}
 export function getCronReloadSignalPath() {
     return path.join(getBeecorkHome(), '.cron-reload');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.4.9",
+  "version": "1.4.11",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
     "test": "vitest",
     "lint": "eslint src/",
     "build:css": "tailwindcss --content src/dashboard/html.ts --minify",
-    "prepublishOnly": "npm test && npm run build"
+    "prepublishOnly": "npm test && npm run build",
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -42,7 +43,8 @@
     "vitest": "^4.1.4"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "scripts/postinstall.mjs"
   ],
   "keywords": [
     "claude",

package/scripts/postinstall.mjs

@@ -0,0 +1,50 @@
+#!/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`);
+}