@matthesketh/fleet 1.1.0 → 1.6.0

package/dist/core/logs-multi.js

@@ -0,0 +1,163 @@
+/**
+ * Multi-source log tailer. Spawns `docker logs -f` per selected container,
+ * splits the streams on newlines, applies filters (level / grep / since),
+ * emits structured events to a callback. Caller is responsible for rendering.
+ *
+ * Design notes:
+ *  - Each container gets its own subprocess so a stuck/dead container can't
+ *    block the others.
+ *  - Stdout + stderr are merged. Docker writes app output to stdout for
+ *    json-file driver containers; some apps log errors to stderr.
+ *  - Lines are emitted in arrival order per source. Cross-source ordering
+ *    is best-effort (no global timestamp synchronisation — we don't reorder).
+ *  - stop() kills the entire process group cleanly. Idempotent.
+ *  - Used by both the CLI (`fleet logs --all -f`) and the TUI logs view.
+ */
+import { spawn } from 'node:child_process';
+const LEVEL_RANK = {
+    debug: 0, info: 1, warn: 2, error: 3,
+};
+const LEVEL_PATTERNS = [
+    { level: 'error', re: /\b(error|err|fatal|critical|exception|panic|trace)\b|\bE\d{4}\b/i },
+    { level: 'warn', re: /\b(warn|warning|deprecated)\b/i },
+    { level: 'debug', re: /\b(debug|trace|verbose)\b/i },
+    { level: 'info', re: /\b(info|notice)\b/i },
+];
+/** Best-effort level inference from a line. Returns 'unknown' if nothing matches. */
+export function inferLevel(text) {
+    // First match wins; ordering above puts error before warn etc.
+    for (const { level, re } of LEVEL_PATTERNS)
+        if (re.test(text))
+            return level;
+    return 'unknown';
+}
+/**
+ * Glob-match a container name against a pattern. Supports * wildcards.
+ * `*-postgres` matches `glitchtip-postgres`, `shared-postgres`, etc.
+ */
+export function matchesContainerGlob(name, glob) {
+    const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
+    return re.test(name);
+}
+/**
+ * Resolve a selection spec into a flat list of LogSource entries.
+ * - Empty selection → all containers across all apps
+ * - apps + containers can be combined; intersection wins
+ */
+export function resolveSources(apps, selection = {}) {
+    const allowedAppNames = selection.apps && selection.apps.length > 0
+        ? new Set(selection.apps)
+        : null;
+    const containerGlobs = selection.containers && selection.containers.length > 0
+        ? selection.containers
+        : null;
+    const out = [];
+    for (const app of apps) {
+        if (allowedAppNames && !allowedAppNames.has(app.name))
+            continue;
+        for (const container of app.containers) {
+            if (containerGlobs && !containerGlobs.some(g => matchesContainerGlob(container, g))) {
+                continue;
+            }
+            out.push({ app: app.name, container });
+        }
+    }
+    return out;
+}
+/**
+ * Start tailing the given sources. Calls onLine for every emitted line that
+ * passes the filter chain. Returns a handle for graceful shutdown.
+ *
+ * For test injection, pass a custom `spawnFn` that mimics Node's spawn.
+ */
+export function startMultiTail(sources, opts, onLine, onClose, spawnFn = spawn) {
+    const procs = new Map();
+    const minLevelRank = opts.level ? LEVEL_RANK[opts.level] : -1;
+    const tail = opts.tail ?? 50;
+    const follow = opts.follow !== false;
+    for (const src of sources) {
+        const args = ['logs', '--tail', String(tail)];
+        if (follow)
+            args.push('-f');
+        if (opts.since)
+            args.push('--since', opts.since);
+        args.push(src.container);
+        const proc = spawnFn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        procs.set(src.container, proc);
+        let stdoutBuf = '';
+        let stderrBuf = '';
+        const flushLine = (text) => {
+            if (!text)
+                return;
+            const level = inferLevel(text);
+            if (minLevelRank >= 0 && level !== 'unknown') {
+                const rank = LEVEL_RANK[level];
+                if (rank < minLevelRank)
+                    return;
+            }
+            if (opts.grep && !text.includes(opts.grep))
+                return;
+            onLine({ ts: new Date(), app: src.app, container: src.container, level, text });
+        };
+        const handleChunk = (which) => (chunk) => {
+            const buf = which === 'out' ? stdoutBuf : stderrBuf;
+            const merged = buf + chunk.toString('utf8');
+            const parts = merged.split('\n');
+            const remainder = parts.pop() ?? '';
+            for (const p of parts)
+                flushLine(p);
+            if (which === 'out')
+                stdoutBuf = remainder;
+            else
+                stderrBuf = remainder;
+        };
+        proc.stdout?.on('data', handleChunk('out'));
+        proc.stderr?.on('data', handleChunk('err'));
+        proc.on('close', code => {
+            // Flush any unfinished partial line — common when a container dies between newlines.
+            if (stdoutBuf) {
+                flushLine(stdoutBuf);
+                stdoutBuf = '';
+            }
+            if (stderrBuf) {
+                flushLine(stderrBuf);
+                stderrBuf = '';
+            }
+            procs.delete(src.container);
+            onClose?.(src, code);
+        });
+    }
+    let stopped = false;
+    return {
+        active: () => procs.size,
+        stop: async () => {
+            if (stopped)
+                return;
+            stopped = true;
+            for (const proc of procs.values()) {
+                try {
+                    proc.kill('SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            // Give them a beat to die gracefully, then escalate.
+            await new Promise(resolve => {
+                const deadline = Date.now() + 2000;
+                const tick = () => {
+                    if (procs.size === 0 || Date.now() > deadline) {
+                        for (const proc of procs.values()) {
+                            try {
+                                proc.kill('SIGKILL');
+                            }
+                            catch { /* already dead */ }
+                        }
+                        resolve();
+                        return;
+                    }
+                    setTimeout(tick, 50);
+                };
+                tick();
+            });
+        },
+    };
+}

package/dist/core/logs-policy.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Log policy: per-app retention/size/level configuration. Materialises as a
+ * compose override file (.fleet/logging.override.yml) per app, plus journald
+ * vacuum policy. Conservative defaults applied when unset.
+ */
+import type { AppEntry } from './registry.js';
+export interface LogPolicy {
+    retentionDays: number;
+    maxSizeMB: number;
+    level: 'debug' | 'info' | 'warn' | 'error';
+}
+export declare const DEFAULT_POLICY: LogPolicy;
+export declare function effectivePolicy(app: AppEntry): LogPolicy;
+/**
+ * Build a docker-compose override that sets json-file driver with rotation.
+ * Maps each container to logging.driver/options. Idempotent — overwrites the
+ * single override file completely.
+ */
+export declare function buildComposeOverride(app: AppEntry, policy: LogPolicy): string;
+export declare function overridePath(app: AppEntry): string;
+export declare function writeComposeOverride(app: AppEntry, policy: LogPolicy): string;
+export interface LogStatus {
+    app: string;
+    container: string;
+    driver: string;
+    totalBytes: number | null;
+    oldestEntry: string | null;
+    policyApplied: boolean;
+}
+/** Best-effort docker-side log status. Uses `docker inspect` for driver + size. */
+export declare function getLogStatus(app: AppEntry): LogStatus[];
+/**
+ * Vacuum: for json-file driver with rotation already configured, docker
+ * handles size automatically. We expose a manual prune that:
+ * 1. Truncates the active log file (leaves rotated .1, .2 alone — those age out naturally)
+ * 2. For journald-driven containers, runs `journalctl --vacuum-time=Xd` scoped to the unit
+ *
+ * Returns bytes freed (approximate).
+ */
+export declare function pruneLogs(app: AppEntry, policy: LogPolicy): number;
+/**
+ * Read a slice of container logs with bounded options. Used by enhanced
+ * `fleet logs` and the MCP tool.
+ */
+export interface LogReadOpts {
+    lines?: number;
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    sinceMinutes?: number;
+    grep?: string;
+    maxBytes?: number;
+}
+export declare function readContainerLogs(container: string, opts?: LogReadOpts): {
+    text: string;
+    truncated: boolean;
+};

package/dist/core/logs-policy.js

@@ -0,0 +1,148 @@
+/**
+ * Log policy: per-app retention/size/level configuration. Materialises as a
+ * compose override file (.fleet/logging.override.yml) per app, plus journald
+ * vacuum policy. Conservative defaults applied when unset.
+ */
+import { existsSync, mkdirSync, writeFileSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSafe } from './exec.js';
+export const DEFAULT_POLICY = {
+    retentionDays: 7,
+    maxSizeMB: 100,
+    level: 'info',
+};
+export function effectivePolicy(app) {
+    return {
+        retentionDays: app.logging?.retentionDays ?? DEFAULT_POLICY.retentionDays,
+        maxSizeMB: app.logging?.maxSizeMB ?? DEFAULT_POLICY.maxSizeMB,
+        level: app.logging?.level ?? DEFAULT_POLICY.level,
+    };
+}
+/**
+ * Build a docker-compose override that sets json-file driver with rotation.
+ * Maps each container to logging.driver/options. Idempotent — overwrites the
+ * single override file completely.
+ */
+export function buildComposeOverride(app, policy) {
+    const maxSize = `${policy.maxSizeMB}m`;
+    const maxFile = '3';
+    const services = {};
+    for (const ct of app.containers) {
+        services[ct] = {
+            logging: {
+                driver: 'json-file',
+                options: { 'max-size': maxSize, 'max-file': maxFile },
+            },
+        };
+    }
+    // Tiny YAML emitter — avoids pulling in a yaml dep for two levels of nesting.
+    const lines = ['# Auto-generated by `fleet logs setup`. Do not edit.', 'services:'];
+    for (const [name, cfg] of Object.entries(services)) {
+        lines.push(`  ${name}:`);
+        lines.push(`    logging:`);
+        lines.push(`      driver: json-file`);
+        lines.push(`      options:`);
+        lines.push(`        max-size: "${cfg.logging.options['max-size']}"`);
+        lines.push(`        max-file: "${cfg.logging.options['max-file']}"`);
+    }
+    return lines.join('\n') + '\n';
+}
+export function overridePath(app) {
+    return join(app.composePath, '.fleet', 'logging.override.yml');
+}
+export function writeComposeOverride(app, policy) {
+    const path = overridePath(app);
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, buildComposeOverride(app, policy));
+    return path;
+}
+/** Best-effort docker-side log status. Uses `docker inspect` for driver + size. */
+export function getLogStatus(app) {
+    const override = overridePath(app);
+    const policyApplied = existsSync(override);
+    const out = [];
+    for (const ct of app.containers) {
+        const inspect = execSafe('docker', ['inspect', '--format={{.HostConfig.LogConfig.Type}}|{{.LogPath}}', ct]);
+        if (!inspect.ok) {
+            out.push({ app: app.name, container: ct, driver: 'unknown', totalBytes: null, oldestEntry: null, policyApplied });
+            continue;
+        }
+        const [driver, logPath] = inspect.stdout.trim().split('|');
+        let totalBytes = null;
+        if (logPath && existsSync(logPath)) {
+            try {
+                totalBytes = statSync(logPath).size;
+            }
+            catch { /* ignore */ }
+        }
+        out.push({ app: app.name, container: ct, driver, totalBytes, oldestEntry: null, policyApplied });
+    }
+    return out;
+}
+/**
+ * Vacuum: for json-file driver with rotation already configured, docker
+ * handles size automatically. We expose a manual prune that:
+ * 1. Truncates the active log file (leaves rotated .1, .2 alone — those age out naturally)
+ * 2. For journald-driven containers, runs `journalctl --vacuum-time=Xd` scoped to the unit
+ *
+ * Returns bytes freed (approximate).
+ */
+export function pruneLogs(app, policy) {
+    let freed = 0;
+    const status = getLogStatus(app);
+    for (const s of status) {
+        if (s.driver === 'json-file' && s.totalBytes && s.totalBytes > 0) {
+            // Use docker to "logs --truncate" — actually no such cmd. Use docker stop + log file truncate? Risky.
+            // Safest: skip active truncation; let docker rotation handle it. Just report.
+            // We DO truncate via writing 0-length only if the file is over 5x the policy max
+            // (which means rotation isn't catching up — clear it manually).
+            const maxBytes = policy.maxSizeMB * 1024 * 1024;
+            if (s.totalBytes > maxBytes * 5) {
+                try {
+                    const inspect = execSafe('docker', ['inspect', '--format={{.LogPath}}', s.container]);
+                    const path = inspect.stdout.trim();
+                    if (path) {
+                        const beforeSize = s.totalBytes;
+                        writeFileSync(path, '');
+                        freed += beforeSize;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    // Journald scope: vacuum by time, scoped to relevant units (best-effort).
+    execSafe('journalctl', ['--vacuum-time', `${policy.retentionDays}d`]);
+    return freed;
+}
+const LEVEL_PATTERNS = {
+    debug: /\b(debug|trace|verbose)\b/i,
+    info: /\b(info|warn|warning|error|err|fatal|critical)\b/i,
+    warn: /\b(warn|warning|error|err|fatal|critical)\b/i,
+    error: /\b(error|err|fatal|critical|exception|panic)\b/i,
+};
+export function readContainerLogs(container, opts = {}) {
+    const args = ['logs', '--tail', String(opts.lines ?? 100)];
+    if (opts.sinceMinutes)
+        args.push('--since', `${opts.sinceMinutes}m`);
+    args.push(container);
+    const r = execSafe('docker', args);
+    if (!r.ok)
+        return { text: r.stderr, truncated: false };
+    let text = r.stdout;
+    if (opts.level) {
+        const pat = LEVEL_PATTERNS[opts.level];
+        text = text.split('\n').filter(l => pat.test(l) || l.trim() === '').join('\n');
+    }
+    if (opts.grep) {
+        const g = opts.grep;
+        text = text.split('\n').filter(l => l.includes(g)).join('\n');
+    }
+    const cap = opts.maxBytes ?? 200_000;
+    if (text.length > cap) {
+        return { text: text.slice(0, cap), truncated: true };
+    }
+    return { text, truncated: false };
+}

package/dist/core/nginx.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { exec } from './exec.js';
+import { execSafe } from './exec.js';
+import { assertDomain } from './validate.js';
 const SITES_AVAILABLE = '/etc/nginx/sites-available';
 const SITES_ENABLED = '/etc/nginx/sites-enabled';
 export function listSites() {
@@ -15,14 +16,16 @@ export function listSites() {
     });
 }
 export function installConfig(domain, content) {
+    assertDomain(domain);
     const filename = `${domain}.conf`;
     writeFileSync(`${SITES_AVAILABLE}/${filename}`, content);
     const enabledPath = `${SITES_ENABLED}/${filename}`;
     if (!existsSync(enabledPath)) {
-        exec(`ln -sf ${SITES_AVAILABLE}/${filename} ${enabledPath}`);
+        execSafe('ln', ['-sf', `${SITES_AVAILABLE}/${filename}`, enabledPath]);
     }
 }
 export function removeConfig(domain) {
+    assertDomain(domain);
     const filename = `${domain}.conf`;
     const available = `${SITES_AVAILABLE}/${filename}`;
     const enabled = `${SITES_ENABLED}/${filename}`;
@@ -35,13 +38,14 @@ export function removeConfig(domain) {
     return false;
 }
 export function testConfig() {
-    const result = exec('nginx -t 2>&1', { timeout: 10_000 });
+    const result = execSafe('nginx', ['-t'], { timeout: 10_000 });
     return { ok: result.ok || result.stderr.includes('successful'), output: result.stderr || result.stdout };
 }
 export function reload() {
-    return exec('systemctl reload nginx', { timeout: 10_000 }).ok;
+    return execSafe('systemctl', ['reload', 'nginx'], { timeout: 10_000 }).ok;
 }
 export function readConfig(domain) {
+    assertDomain(domain);
     const path = `${SITES_AVAILABLE}/${domain}.conf`;
     if (!existsSync(path))
         return null;

package/dist/core/notify.d.ts

@@ -0,0 +1,15 @@
+export interface NotifyAdapterConfig {
+    type: 'bluebubbles' | 'telegram';
+    serverUrl?: string;
+    password?: string;
+    chatGuid?: string;
+    cfAccessClientId?: string;
+    cfAccessClientSecret?: string;
+    botToken?: string;
+    chatId?: string;
+}
+export interface NotifyConfig {
+    adapters: NotifyAdapterConfig[];
+}
+export declare function loadNotifyConfig(): NotifyConfig | null;
+export declare function sendNotification(config: NotifyConfig, message: string): Promise<boolean>;

package/dist/core/notify.js

@@ -0,0 +1,55 @@
+import { readFileSync, existsSync } from 'node:fs';
+const NOTIFY_CONFIG_PATH = '/etc/fleet/notify.json';
+export function loadNotifyConfig() {
+    if (!existsSync(NOTIFY_CONFIG_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(NOTIFY_CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function sendNotification(config, message) {
+    let anySuccess = false;
+    for (const adapter of config.adapters) {
+        try {
+            const ok = adapter.type === 'bluebubbles'
+                ? await sendBlueBubbles(adapter, message)
+                : await sendTelegram(adapter, message);
+            if (ok)
+                anySuccess = true;
+        }
+        catch (err) {
+            console.error(`notify (${adapter.type}): ${err}`);
+        }
+    }
+    return anySuccess;
+}
+async function sendBlueBubbles(cfg, message) {
+    const url = `${cfg.serverUrl}/api/v1/message/text?password=${cfg.password}`;
+    const headers = { 'Content-Type': 'application/json' };
+    if (cfg.cfAccessClientId) {
+        headers['CF-Access-Client-Id'] = cfg.cfAccessClientId;
+        headers['CF-Access-Client-Secret'] = cfg.cfAccessClientSecret;
+    }
+    const res = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            chatGuid: cfg.chatGuid,
+            message,
+            tempGuid: `fleet-${Date.now()}`,
+            method: 'apple-script',
+        }),
+    });
+    return res.ok;
+}
+async function sendTelegram(cfg, message) {
+    const res = await fetch(`https://api.telegram.org/bot${cfg.botToken}/sendMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ chat_id: cfg.chatId, text: message, parse_mode: 'HTML' }),
+    });
+    return res.ok;
+}

package/dist/core/registry.d.ts

@@ -15,7 +15,32 @@ export interface AppEntry {
     gitRepo?: string;
     gitRemoteUrl?: string;
     gitOnboardedAt?: string;
+    lastBuiltCommit?: string;
     registeredAt: string;
+    frozenAt?: string;
+    frozenReason?: string;
+    /** Numeric UID/GID to chown /run/fleet-secrets/<app>/.env to after unseal.
+     * If unset, file remains root:root 0600 (the safe default). Used only for
+     * apps that read the env file directly from the host (rare); Docker apps
+     * using env_file in compose don't need this. */
+    runtimeUid?: number;
+    runtimeGid?: number;
+    /** Per-app age recipient public key (for fleet secrets harden --per-app).
+     * When set, the vault is encrypted to (admin + this) recipients. */
+    ageRecipient?: string;
+    /** Per-app log policy. If unset, defaults are applied (7 days, 100MB, info). */
+    logging?: {
+        retentionDays?: number;
+        maxSizeMB?: number;
+        level?: 'debug' | 'info' | 'warn' | 'error';
+    };
+    /** Per-app outbound egress allowlist. v1 supports `observe` and `shadow` modes
+     * only — `enforce` mode (actual drop via nftables) is deferred to Phase E. */
+    egress?: {
+        mode?: 'observe' | 'shadow';
+        /** Allowlist entries: 'host', 'host:port', or 'cidr/N'. Hosts resolved at check time. */
+        allow?: string[];
+    };
 }
 export interface Registry {
     version: number;

package/dist/core/registry.js

@@ -1,29 +1,76 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, copyFileSync, renameSync, openSync, writeSync, fsyncSync, closeSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const REGISTRY_PATH = join(__dirname, '..', '..', 'data', 'registry.json');
+function resolveRegistryPath() {
+    return process.env.FLEET_REGISTRY_PATH
+        ?? join(__dirname, '..', '..', 'data', 'registry.json');
+}
 function defaultRegistry() {
     return {
         version: 1,
         apps: [],
         infrastructure: {
-            databases: { serviceName: 'docker-databases', composePath: '/home/matt/docker-databases' },
+            databases: { serviceName: 'docker-databases', composePath: '' },
             nginx: { configPath: '/etc/nginx' },
         },
     };
 }
 export function load() {
-    if (!existsSync(REGISTRY_PATH))
-        return defaultRegistry();
-    const raw = readFileSync(REGISTRY_PATH, 'utf-8');
-    return JSON.parse(raw);
+    const path = resolveRegistryPath();
+    const bakPath = path + '.bak';
+    if (existsSync(path)) {
+        try {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            process.stderr.write(`[registry] Warning: failed to parse ${path}, trying ${bakPath}\n`);
+        }
+    }
+    if (existsSync(bakPath)) {
+        try {
+            return JSON.parse(readFileSync(bakPath, 'utf-8'));
+        }
+        catch {
+            process.stderr.write(`[registry] Warning: failed to parse ${bakPath}, using default\n`);
+        }
+    }
+    return defaultRegistry();
 }
 export function save(reg) {
-    const dir = dirname(REGISTRY_PATH);
+    const path = resolveRegistryPath();
+    const dir = dirname(path);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
-    writeFileSync(REGISTRY_PATH, JSON.stringify(reg, null, 2) + '\n');
+    if (existsSync(path)) {
+        let mainIsValid = false;
+        try {
+            JSON.parse(readFileSync(path, 'utf-8'));
+            mainIsValid = true;
+        }
+        catch {
+            process.stderr.write(`[registry] Warning: main registry unparsable, preserving existing .bak\n`);
+        }
+        if (mainIsValid) {
+            try {
+                copyFileSync(path, path + '.bak');
+            }
+            catch (err) {
+                process.stderr.write(`[registry] Warning: failed to write .bak: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    const tmp = path + '.tmp';
+    const data = JSON.stringify(reg, null, 2) + '\n';
+    const fd = openSync(tmp, 'w');
+    try {
+        writeSync(fd, data);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
 }
 export function findApp(reg, name) {
     return reg.apps.find(a => a.name === name || a.serviceName === name || a.displayName.toLowerCase() === name.toLowerCase());
@@ -43,5 +90,5 @@ export function removeApp(reg, name) {
     return reg;
 }
 export function registryPath() {
-    return REGISTRY_PATH;
+    return resolveRegistryPath();
 }

package/dist/core/routines/cost-queries.d.ts

@@ -0,0 +1,24 @@
+import type Database from 'better-sqlite3';
+export interface CostRollup {
+    usdToday: number;
+    usdWeek: number;
+    usdMonth: number;
+    runsToday: number;
+    runsWeek: number;
+    runsMonth: number;
+}
+export interface CostByRoutine {
+    routineId: string;
+    runs: number;
+    usd: number;
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface DailyCostBucket {
+    date: string;
+    usd: number;
+    runs: number;
+}
+export declare function costRollup(db: Database.Database): CostRollup;
+export declare function costByRoutine(db: Database.Database, days?: number, limit?: number): CostByRoutine[];
+export declare function dailyCostSeries(db: Database.Database, days?: number): DailyCostBucket[];