beecork 1.4.11 → 1.6.0

package/dist/session/tab-store.js

@@ -0,0 +1,78 @@
+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

@@ -6,6 +6,7 @@ export declare class TaskScheduler {
     private onNotify;
     private nextRunAt;
     private running;
+    private failureCounts;
     private stopping;
     private store;
     constructor(tabManager: TabManager, onNotify: NotifyCallback | null);
@@ -24,9 +25,21 @@ export declare class TaskScheduler {
     /** Compute next run time in ms epoch, given a "from" anchor. Returns null if invalid. */
     private computeNextRun;
     private fireJob;
+    /**
+     * Track consecutive failures per task. After MAX_CONSECUTIVE_FAILURES the
+     * task is auto-disabled in the DB and a single "auto-disabled" notification
+     * is sent. Counter resets on the next successful fire.
+     */
+    private recordFailure;
     private handleSystemEvent;
 }
 /** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
 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

@@ -7,6 +7,12 @@ import { TaskStore } from './store.js';
 import { getCronReloadSignalPath, getLogsDir } from '../util/paths.js';
 import { logger } from '../util/logger.js';
 export const execAsync = promisify(exec);
+/**
+ * Disable a task after this many consecutive failures so a misconfigured
+ * cron doesn't fire (and notify) every interval indefinitely. Reset on
+ * success.
+ */
+const MAX_CONSECUTIVE_FAILURES = 5;
 export class TaskScheduler {
     tabManager;
     onNotify;
@@ -14,6 +20,8 @@ export class TaskScheduler {
     nextRunAt = new Map();
     // taskIds with an in-flight fireJob
     running = new Set();
+    // taskId -> consecutive failure count, used for auto-disable
+    failureCounts = new Map();
     stopping = false;
     store = new TaskStore();
     constructor(tabManager, onNotify) {
@@ -69,7 +77,9 @@ export class TaskScheduler {
             try {
                 fs.unlinkSync(signalPath);
             }
-            catch { /* race condition, ok */ }
+            catch {
+                /* race condition, ok */
+            }
             logger.info('Tasks: reload signal detected, reloading schedules');
             this.loadAndSchedule();
         }
@@ -124,11 +134,15 @@ export class TaskScheduler {
         try {
             switch (job.scheduleType) {
                 case 'cron':
-                    return CronExpressionParser.parse(job.schedule, { currentDate: new Date(fromMs) }).next().getTime();
+                    return CronExpressionParser.parse(job.schedule, { currentDate: new Date(fromMs) })
+                        .next()
+                        .getTime();
                 case 'every': {
                     const expr = intervalToCron(job.schedule);
                     if (expr) {
-                        return CronExpressionParser.parse(expr, { currentDate: new Date(fromMs) }).next().getTime();
+                        return CronExpressionParser.parse(expr, { currentDate: new Date(fromMs) })
+                            .next()
+                            .getTime();
                     }
                     const ms = intervalToMs(job.schedule);
                     return ms ? fromMs + ms : null;
@@ -169,6 +183,12 @@ export class TaskScheduler {
             const status = result.error ? 'ERROR' : 'SUCCESS';
             // Log result (status reflects subprocess exit / is_error, not just completion)
             await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ${status}: ${firstLine}\n`);
+            if (result.error) {
+                this.recordFailure(job);
+            }
+            else {
+                this.failureCounts.delete(job.id);
+            }
             // Notify (separate try/catch -- notification failure shouldn't be reported as job failure)
             try {
                 if (this.onNotify) {
@@ -188,10 +208,30 @@ export class TaskScheduler {
             const errMsg = err instanceof Error ? err.message : String(err);
             logger.error(`Task "${job.name}" failed:`, err);
             await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
+            this.recordFailure(job);
             try {
                 await this.onNotify?.(`[${job.name}] Failed -- ${errMsg}`);
             }
-            catch { /* notification best-effort */ }
+            catch {
+                /* notification best-effort */
+            }
+        }
+    }
+    /**
+     * Track consecutive failures per task. After MAX_CONSECUTIVE_FAILURES the
+     * task is auto-disabled in the DB and a single "auto-disabled" notification
+     * is sent. Counter resets on the next successful fire.
+     */
+    recordFailure(job) {
+        const count = (this.failureCounts.get(job.id) ?? 0) + 1;
+        this.failureCounts.set(job.id, count);
+        if (count >= MAX_CONSECUTIVE_FAILURES) {
+            logger.warn(`Task "${job.name}" hit ${count} consecutive failures — auto-disabling`);
+            this.store.update(job.id, { enabled: false });
+            this.nextRunAt.delete(job.id);
+            this.failureCounts.delete(job.id);
+            // Notify once. Subsequent enable + re-failure will trigger again.
+            this.onNotify?.(`Task "${job.name}" auto-disabled after ${count} consecutive failures. Re-enable from the dashboard or via beecork_task_update.`).catch(() => { });
         }
     }
     async handleSystemEvent(job) {
@@ -207,28 +247,33 @@ export class TaskScheduler {
         }
     }
 }
+/** 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;
+    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 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 totalMs = ((weeks * 7 * 24 * 60) + (days * 24 * 60) + (hours * 60) + mins) * 60 * 1000;
+    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 +293,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

@@ -4,21 +4,33 @@ import { getCrontabPath } from '../util/paths.js';
 import { logger } from '../util/logger.js';
 function rowToTask(row) {
     return {
-        id: row.id, name: row.name,
+        id: row.id,
+        name: row.name,
         scheduleType: row.schedule_type,
-        schedule: row.schedule, tabName: row.tab_name, message: row.message,
+        schedule: row.schedule,
+        tabName: row.tab_name,
+        message: row.message,
         payloadType: row.payload_type || 'agentTurn',
-        enabled: row.enabled === 1, createdAt: row.created_at,
-        lastRunAt: row.last_run_at, nextRunAt: row.next_run_at,
+        enabled: row.enabled === 1,
+        createdAt: row.created_at,
+        lastRunAt: row.last_run_at,
+        nextRunAt: row.next_run_at,
     };
 }
+// One-shot JSON migration only needs to run once per process lifetime, but the
+// dashboard creates a fresh TaskStore per request and MCP creates one per task
+// call. Without this flag, every instantiation re-fired existsSync + COUNT(*).
+let migrationChecked = false;
 export class TaskStore {
     constructor() {
-        this.migrateFromJson();
+        if (!migrationChecked) {
+            migrationChecked = true;
+            this.migrateFromJson();
+        }
     }
     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 +39,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();
@@ -63,7 +75,9 @@ export class TaskStore {
             try {
                 fs.renameSync(jsonPath, jsonPath + '.bak');
             }
-            catch { /* ok */ }
+            catch {
+                /* ok */
+            }
             return;
         }
         try {
@@ -71,11 +85,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/logger.js

@@ -5,5 +5,7 @@ export function logActivity(eventType, summary, options) {
         const db = getDb();
         db.prepare('INSERT INTO activity_log (id, event_type, project_name, tab_name, summary, details, duration_ms, cost_usd) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(uuidv4(), eventType, options?.projectName || null, options?.tabName || null, summary, options?.details || null, options?.durationMs || null, options?.costUsd || null);
     }
-    catch { /* non-critical — don't crash if logging fails */ }
+    catch {
+        /* non-critical — don't crash if logging fails */
+    }
 }

package/dist/timeline/query.js

@@ -1,9 +1,15 @@
 import { getDb } from '../db/index.js';
 function rowToEvent(r) {
     return {
-        id: r.id, eventType: r.event_type, projectName: r.project_name,
-        tabName: r.tab_name, summary: r.summary, details: r.details,
-        durationMs: r.duration_ms, costUsd: r.cost_usd, createdAt: r.created_at,
+        id: r.id,
+        eventType: r.event_type,
+        projectName: r.project_name,
+        tabName: r.tab_name,
+        summary: r.summary,
+        details: r.details,
+        durationMs: r.duration_ms,
+        costUsd: r.cost_usd,
+        createdAt: r.created_at,
     };
 }
 export function getTimeline(options) {
@@ -12,8 +18,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,10 +8,11 @@ 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;
-    maxLongTermEntries: number;
 }
 export interface TabConfig {
     workingDir: string;
@@ -25,6 +26,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,12 +40,29 @@ export interface VoiceConfig {
 export interface DiscordConfig {
     token: string;
     allowedUserIds?: string[];
-}
+    /** Optional admin user ID. Defaults to allowedUserIds[0]. */
+    adminUserId?: string;
+}
+/**
+ * Webhook channel auth semantics:
+ *
+ * - When both `authToken` and `hmacSecret` are configured, EITHER mode
+ *   satisfies authentication (OR semantics). A valid Bearer token is enough
+ *   even if the HMAC signature is missing. There is no AND mode today.
+ * - Replay protection is NOT implemented. Callers must keep their payloads
+ *   idempotent — see L10 in the audit. Acceptable while the server binds to
+ *   127.0.0.1 only; revisit if remote exposure becomes a thing.
+ * - `allowUnauthLocalhost` is the explicit opt-in to run with no auth at all.
+ *   Useful for `curl localhost` from a trusted shell, but on a multi-user
+ *   host any local process can inject prompts into your tabs.
+ */
 export interface WebhookConfig {
     enabled: boolean;
     port: number;
     authToken?: string;
     hmacSecret?: string;
+    /** Set to true to skip the fail-secure auth check at start. NOT recommended on shared hosts. */
+    allowUnauthLocalhost?: boolean;
 }
 export interface GroupConfig {
     activationMode: 'mention' | 'reply' | 'keyword' | 'always';
@@ -50,21 +70,39 @@ export interface GroupConfig {
     tabPerGroup: boolean;
     keywords?: string[];
 }
-export interface NotificationConfig {
-    type: 'pushover' | 'ntfy' | 'webhook';
-    userKey?: string;
-    appToken?: string;
-    topic?: string;
+/**
+ * Discriminated union of notification provider configs. The `type` field
+ * narrows which fields are required so callers get full type safety instead
+ * of treating every field as optional. createNotificationProvider switches
+ * exhaustively on `type`.
+ */
+export type NotificationConfig = {
+    type: 'pushover';
+    userKey: string;
+    appToken: string;
+} | {
+    type: 'ntfy';
+    topic: string;
     server?: string;
-    url?: string;
+} | {
+    type: 'webhook';
+    url: string;
     headers?: Record<string, string>;
-}
+};
 export interface MediaGeneratorConfig {
     provider: string;
     apiKey?: string;
     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;
+    caption?: string;
+}
 export interface BeecorkConfig {
     telegram: TelegramConfig;
     whatsapp?: WhatsAppConfig;
@@ -81,6 +119,8 @@ export interface BeecorkConfig {
     notifications?: NotificationConfig[];
     mediaGenerators?: MediaGeneratorConfig[];
     communityChannels?: string[];
+    /** Capability packs enabled via `beecork capabilities enable`. Owned by src/capabilities. */
+    capabilities?: import('./capabilities/types.js').EnabledCapability[];
     deployment: 'local' | 'vps';
 }
 export type TabStatus = 'idle' | 'running' | 'error' | 'stopped';

package/dist/util/auto-heal.js

@@ -41,10 +41,20 @@ export function autoHealInstall(fromFileUrl) {
             }
         }
         if (rewroteUnit && signaledDaemon) {
-            return { action: 'rewrote-and-signaled', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+            return {
+                action: 'rewrote-and-signaled',
+                unitPath,
+                oldDaemonScript: oldDaemonScript,
+                newDaemonScript: currentDaemonScript,
+            };
         }
         if (rewroteUnit)
-            return { action: 'rewrote-unit', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+            return {
+                action: 'rewrote-unit',
+                unitPath,
+                oldDaemonScript: oldDaemonScript,
+                newDaemonScript: currentDaemonScript,
+            };
         if (signaledDaemon)
             return { action: 'signaled-daemon', unitPath };
         return { action: 'noop' };
@@ -64,8 +74,8 @@ 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'));
+        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;
     }
@@ -73,7 +83,7 @@ export function extractDaemonScript(content) {
     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'));
+        const jsArg = parts.find((p) => p.endsWith('daemon.js'));
         if (jsArg)
             return jsArg;
     }

package/dist/util/install-info.js

@@ -52,7 +52,9 @@ export function removeRuntimeInfo() {
     try {
         fs.unlinkSync(filePath);
     }
-    catch { /* not present, fine */ }
+    catch {
+        /* not present, fine */
+    }
 }
 export function isPidAlive(pid) {
     try {

package/dist/util/logger.d.ts

@@ -3,7 +3,7 @@ declare class Logger {
     private minLevel;
     private logFile;
     private stream;
-    private writeCount;
+    private bytesWritten;
     setLevel(level: LogLevel): void;
     setLogFile(name: string): void;
     private write;