@moneysiren/cli 0.1.0-alpha.0

package/dist/packages/report/src/slack.js

@@ -0,0 +1,134 @@
+export class SlackReportDeliveryError extends Error {
+    statusCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "SlackReportDeliveryError";
+        if (options.statusCode !== undefined) {
+            this.statusCode = options.statusCode;
+        }
+    }
+}
+const DEFAULT_SLACK_REPORT_TIMEOUT_MS = 5_000;
+const MAX_SLACK_ERROR_MESSAGE_LENGTH = 500;
+const MAX_SLACK_RESPONSE_BODY_LENGTH = 300;
+const TRUNCATED_SUFFIX = "... [truncated]";
+export function buildSlackReportPayload(text) {
+    const trimmedText = text.trim();
+    if (trimmedText.length === 0) {
+        throw new SlackReportDeliveryError("Slack report text must not be blank.");
+    }
+    return {
+        text: trimmedText,
+        mrkdwn: true,
+    };
+}
+export async function sendSlackReport(options) {
+    const webhookUrl = normalizeWebhookUrl(options.webhookUrl);
+    const payload = buildSlackReportPayload(options.text);
+    const transport = options.transport ?? fetchSlackReportTransport;
+    const timeoutMs = resolveSlackReportTimeoutMs(options.timeoutMs);
+    const controller = new AbortController();
+    let timeout;
+    let response;
+    try {
+        const transportPromise = transport({
+            webhookUrl,
+            payload,
+            signal: controller.signal,
+        });
+        transportPromise.catch(() => undefined);
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timeout = setTimeout(() => {
+                controller.abort();
+                reject(new SlackReportDeliveryError(`Slack report delivery timed out after ${timeoutMs}ms.`));
+            }, timeoutMs);
+        });
+        response = await Promise.race([transportPromise, timeoutPromise]);
+    }
+    catch (error) {
+        const message = error instanceof SlackReportDeliveryError
+            ? error.message
+            : `Slack report delivery failed: ${errorMessage(error)}`;
+        const errorOptions = error instanceof SlackReportDeliveryError && error.statusCode !== undefined
+            ? { statusCode: error.statusCode }
+            : {};
+        throw new SlackReportDeliveryError(sanitizeWebhookMessage(message, webhookUrl), errorOptions);
+    }
+    finally {
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+        }
+    }
+    if (!response.ok) {
+        const responseBody = formatResponseBodyDetail(response.body, webhookUrl);
+        const responseDetail = responseBody === undefined
+            ? ""
+            : ` Response: ${responseBody}`;
+        throw new SlackReportDeliveryError(sanitizeWebhookMessage(`Slack report delivery failed with HTTP ${response.status}.${responseDetail}`, webhookUrl), {
+            statusCode: response.status,
+        });
+    }
+    return {
+        status: "sent",
+        statusCode: response.status,
+    };
+}
+async function fetchSlackReportTransport(request) {
+    const response = await fetch(request.webhookUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(request.payload),
+        signal: request.signal,
+    });
+    const body = await response.text();
+    return {
+        ok: response.ok,
+        status: response.status,
+        ...(body.length === 0 ? {} : { body }),
+    };
+}
+function normalizeWebhookUrl(webhookUrl) {
+    const trimmed = webhookUrl.trim();
+    if (trimmed.length === 0) {
+        throw new SlackReportDeliveryError("SLACK_WEBHOOK_URL is required for Slack delivery.");
+    }
+    return trimmed;
+}
+function resolveSlackReportTimeoutMs(timeoutMs) {
+    if (timeoutMs === undefined) {
+        return DEFAULT_SLACK_REPORT_TIMEOUT_MS;
+    }
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new SlackReportDeliveryError("Slack report timeout must be a positive safe integer.");
+    }
+    return timeoutMs;
+}
+function formatResponseBodyDetail(body, webhookUrl) {
+    const trimmedBody = body?.trim();
+    if (trimmedBody === undefined || trimmedBody.length === 0) {
+        return undefined;
+    }
+    return limitText(redactSensitiveText(trimmedBody, webhookUrl), MAX_SLACK_RESPONSE_BODY_LENGTH);
+}
+function sanitizeWebhookMessage(message, webhookUrl) {
+    return limitText(redactSensitiveText(message, webhookUrl), MAX_SLACK_ERROR_MESSAGE_LENGTH);
+}
+function redactSensitiveText(message, webhookUrl) {
+    return message
+        .replaceAll(webhookUrl, "[REDACTED:webhook_url]")
+        .replace(/https:\/\/hooks\.slack\.com\/services\/[^\s"')]+/gi, "[REDACTED:webhook_url]")
+        .replace(/\bsk-[A-Za-z0-9_-]+/g, "[REDACTED:token]")
+        .replace(/\bxox[baprs]-[A-Za-z0-9-]+/gi, "[REDACTED:token]");
+}
+function limitText(message, maxLength) {
+    if (message.length <= maxLength) {
+        return message;
+    }
+    return `${message.slice(0, maxLength - TRUNCATED_SUFFIX.length)}${TRUNCATED_SUFFIX}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=slack.js.map

package/dist/packages/runtime/src/index.d.ts

@@ -0,0 +1,2 @@
+export { assertLoopbackHost, assertRuntimeHealthy, findRuntime, isLoopbackHost, readRuntimeLock, removeRuntimeLock, resolveRuntimeLockPath, writeRuntimeLock, type LocalRuntime, type RuntimeHealthCheckOptions, type RuntimeLockOptions, } from "./runtime.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/runtime/src/index.js

@@ -0,0 +1,2 @@
+export { assertLoopbackHost, assertRuntimeHealthy, findRuntime, isLoopbackHost, readRuntimeLock, removeRuntimeLock, resolveRuntimeLockPath, writeRuntimeLock, } from "./runtime.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/runtime/src/runtime.d.ts

@@ -0,0 +1,26 @@
+export interface LocalRuntime {
+    pid: number;
+    port: number;
+    baseUrl: string;
+    startedAt: string;
+    version: string;
+}
+export interface RuntimeLockOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    lockPath?: string;
+    platform?: NodeJS.Platform;
+}
+export interface RuntimeHealthCheckOptions {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare function isLoopbackHost(host: string): boolean;
+export declare function assertLoopbackHost(host: string): void;
+export declare function resolveRuntimeLockPath(options?: RuntimeLockOptions): string;
+export declare function readRuntimeLock(options?: RuntimeLockOptions): Promise<LocalRuntime | null>;
+export declare function writeRuntimeLock(runtime: LocalRuntime, options?: RuntimeLockOptions): Promise<string>;
+export declare function removeRuntimeLock(options?: RuntimeLockOptions): Promise<void>;
+export declare function findRuntime(options?: RuntimeLockOptions): Promise<LocalRuntime | null>;
+export declare function assertRuntimeHealthy(runtime: LocalRuntime, options?: RuntimeHealthCheckOptions): Promise<boolean>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/packages/runtime/src/runtime.js

@@ -0,0 +1,182 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, posix, win32 } from "node:path";
+const RUNTIME_LOCK_ENV_KEY = "MONEYSIREN_RUNTIME_LOCK_PATH";
+const DEFAULT_HEALTH_TIMEOUT_MS = 2_000;
+export function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+    return (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "0:0:0:0:0:0:0:1" ||
+        normalized.startsWith("127."));
+}
+export function assertLoopbackHost(host) {
+    if (!isLoopbackHost(host)) {
+        throw new Error("MoneySiren local runtime must bind to a loopback host.");
+    }
+}
+export function resolveRuntimeLockPath(options = {}) {
+    if (options.lockPath !== undefined && options.lockPath.trim().length > 0) {
+        return resolveRuntimePath(options.lockPath, options.cwd);
+    }
+    const configuredPath = options.env?.[RUNTIME_LOCK_ENV_KEY]?.trim();
+    if (configuredPath !== undefined && configuredPath.length > 0) {
+        return resolveRuntimePath(configuredPath, options.cwd);
+    }
+    return defaultRuntimeLockPath(options.env ?? process.env, options.platform ?? process.platform);
+}
+export async function readRuntimeLock(options = {}) {
+    const lockPath = resolveRuntimeLockPath(options);
+    try {
+        const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+        return parseRuntime(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeRuntimeLock(runtime, options = {}) {
+    const parsedUrl = parseLoopbackUrl(runtime.baseUrl);
+    if (parsedUrl.port !== String(runtime.port)) {
+        throw new Error("Runtime lock baseUrl port must match the runtime port.");
+    }
+    const lockPath = resolveRuntimeLockPath(options);
+    await mkdir(dirname(lockPath), { recursive: true });
+    await writeFile(lockPath, `${JSON.stringify(runtime, null, 2)}\n`, "utf8");
+    return lockPath;
+}
+export async function removeRuntimeLock(options = {}) {
+    await rm(resolveRuntimeLockPath(options), {
+        force: true,
+    });
+}
+export async function findRuntime(options = {}) {
+    const runtime = await readRuntimeLock(options);
+    if (runtime === null) {
+        return null;
+    }
+    if (!isProcessAlive(runtime.pid)) {
+        await removeStaleRuntimeLock(options);
+        return null;
+    }
+    return runtime;
+}
+export async function assertRuntimeHealthy(runtime, options = {}) {
+    parseLoopbackUrl(runtime.baseUrl);
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_HEALTH_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(`${runtime.baseUrl}/api/local/health`, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return false;
+        }
+        const payload = await response.json();
+        return payload.secretsReturned === false;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function removeStaleRuntimeLock(options) {
+    try {
+        await removeRuntimeLock(options);
+    }
+    catch {
+        // A stale lock must not make status commands fail, especially after npm/global installs.
+    }
+}
+function parseRuntime(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const pid = value.pid;
+    const port = value.port;
+    const baseUrl = value.baseUrl;
+    const startedAt = value.startedAt;
+    const version = value.version;
+    if (typeof pid !== "number" ||
+        typeof port !== "number" ||
+        typeof baseUrl !== "string" ||
+        typeof startedAt !== "string" ||
+        typeof version !== "string" ||
+        !Number.isSafeInteger(pid) ||
+        !Number.isSafeInteger(port)) {
+        return null;
+    }
+    try {
+        parseLoopbackUrl(baseUrl);
+    }
+    catch {
+        return null;
+    }
+    return {
+        pid,
+        port,
+        baseUrl,
+        startedAt,
+        version,
+    };
+}
+function parseLoopbackUrl(value) {
+    const parsedUrl = new URL(value);
+    if (parsedUrl.protocol !== "http:") {
+        throw new Error("MoneySiren local runtime must use http on loopback.");
+    }
+    assertLoopbackHost(parsedUrl.hostname);
+    return parsedUrl;
+}
+function resolveRuntimePath(path, cwd = process.cwd()) {
+    return isAbsolute(path) ? path : join(cwd, path);
+}
+function defaultRuntimeLockPath(env, platform) {
+    if (platform === "darwin") {
+        return joinForPlatform(platform, resolveHomeDirectory(env), "Library", "Application Support", "MoneySiren", "runtime.json");
+    }
+    if (platform === "win32") {
+        return joinForPlatform(platform, resolveWindowsAppDataDirectory(env), "MoneySiren", "runtime.json");
+    }
+    const configHome = trimToNull(env.XDG_CONFIG_HOME) ?? joinForPlatform(platform, resolveHomeDirectory(env), ".config");
+    return joinForPlatform(platform, configHome, "moneysiren", "runtime.json");
+}
+function resolveWindowsAppDataDirectory(env) {
+    return trimToNull(env.APPDATA) ?? win32.join(resolveHomeDirectory(env), "AppData", "Roaming");
+}
+function resolveHomeDirectory(env) {
+    return trimToNull(env.HOME) ?? trimToNull(env.USERPROFILE) ?? homedir();
+}
+function trimToNull(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed.length === 0 ? null : trimmed;
+}
+function joinForPlatform(platform, ...segments) {
+    return platform === "win32" ? win32.join(...segments) : posix.join(...segments);
+}
+function isProcessAlive(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isNodeError(value) {
+    return value instanceof Error && "code" in value;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/packages/view-model/src/index.d.ts

@@ -0,0 +1,3 @@
+export { buildNotificationDigest, buildOperationsOverview, buildTodayLiveView, buildTrayMenuModel, readNotificationDigest, readOperationsOverview, readTodayLiveView, readTrayMenuModel, type LocalSafeEnvelope, type NotificationDigest, type NotificationDigestItem, type OperationsOverview, type OperationsOverviewAlert, type OperationsOverviewProvider, type ReadNotificationDigestOptions, type ReadOperationsOverviewOptions, type ReadTodayLiveViewOptions, type ReadTrayMenuModelOptions, type TodayLiveProviderInput, type TodayLiveProviderView, type TodayLiveView, type TrayMenuItem, type TrayMenuModel, type ViewModelAlertRecord, type ViewModelBillingSnapshotRecord, type ViewModelCostEstimateRecord, type ViewModelHealthStatus, type ViewModelProviderRecord, type ViewModelReadStore, type ViewModelRiskSeverity, type ViewModelServiceHealthSnapshotRecord, type ViewModelStore, type ViewModelUsageSnapshotRecord, } from "./view-model.js";
+export { cloneNotificationPreferences, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, readNotificationPreferencesFile, resolveNotificationPreferencesPath, writeNotificationPreferencesFile, type DashboardDisplayPreferences, type DigestInterval, type LocalCliDashboardMetricKey, type NotificationPreferenceFileOptions, type NotificationPreferences, type NotificationThresholdRule, type NotificationWidgetKey, type ThresholdOperator, } from "./notification-preferences.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/view-model/src/index.js

@@ -0,0 +1,3 @@
+export { buildNotificationDigest, buildOperationsOverview, buildTodayLiveView, buildTrayMenuModel, readNotificationDigest, readOperationsOverview, readTodayLiveView, readTrayMenuModel, } from "./view-model.js";
+export { cloneNotificationPreferences, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, readNotificationPreferencesFile, resolveNotificationPreferencesPath, writeNotificationPreferencesFile, } from "./notification-preferences.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/view-model/src/notification-preferences-model.d.ts

@@ -0,0 +1,47 @@
+export declare const NOTIFICATION_WIDGET_KEYS: readonly ["month_forecast", "today_live_cost", "risk_high_count", "stale_connection_count", "aws_month_forecast", "openai_today_cost", "openai_today_tokens", "claude_five_hour_percent", "claude_weekly_percent", "codex_five_hour_percent", "codex_weekly_percent", "supabase_usage_health", "cloudflare_month_to_date"];
+export declare const LOCAL_CLI_DASHBOARD_METRIC_KEYS: readonly ["context_percent", "last_request_tokens", "total_tokens", "five_hour_limit_percent", "weekly_limit_percent", "five_hour_remaining_tokens", "weekly_remaining_tokens", "context_tokens", "input_tokens", "output_tokens", "cache_tokens", "reasoning_tokens", "sessions", "turns", "tool_calls", "log_files"];
+export type NotificationWidgetKey = (typeof NOTIFICATION_WIDGET_KEYS)[number];
+export type LocalCliDashboardMetricKey = (typeof LOCAL_CLI_DASHBOARD_METRIC_KEYS)[number];
+export type ThresholdOperator = "gte" | "lte" | "eq";
+export type DigestInterval = "six-hours" | "daily" | "weekly";
+export interface NotificationThresholdRule {
+    widgetKey: NotificationWidgetKey;
+    operator: ThresholdOperator;
+    value: number;
+    cooldownMinutes: number;
+}
+export interface NotificationPreferences {
+    enabled: boolean;
+    digestEnabled: boolean;
+    digestInterval: DigestInterval;
+    quietHours: {
+        start: string;
+        end: string;
+    };
+    selectedWidgets: readonly NotificationWidgetKey[];
+    thresholdRules: readonly NotificationThresholdRule[];
+    desktopEnabled: boolean;
+    dashboard: DashboardDisplayPreferences;
+    hud: HudPreferences;
+}
+export interface DashboardDisplayPreferences {
+    localCliMetricKeys: readonly LocalCliDashboardMetricKey[];
+}
+export interface HudPreferences {
+    alwaysOnTop: boolean;
+    fontScale: number;
+    opacity: number;
+    selectedWidgets: readonly NotificationWidgetKey[];
+}
+export interface NotificationPreferenceFileOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    path?: string;
+}
+export declare const DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS: readonly NotificationWidgetKey[];
+export declare const DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS: readonly LocalCliDashboardMetricKey[];
+export declare const DEFAULT_NOTIFICATION_THRESHOLD_RULES: readonly NotificationThresholdRule[];
+export declare const DEFAULT_NOTIFICATION_PREFERENCES: NotificationPreferences;
+export declare function parseNotificationPreferences(value: unknown): NotificationPreferences;
+export declare function cloneNotificationPreferences(preferences: NotificationPreferences): NotificationPreferences;
+//# sourceMappingURL=notification-preferences-model.d.ts.map

package/dist/packages/view-model/src/notification-preferences-model.js

@@ -0,0 +1,218 @@
+export const NOTIFICATION_WIDGET_KEYS = [
+    "month_forecast",
+    "today_live_cost",
+    "risk_high_count",
+    "stale_connection_count",
+    "aws_month_forecast",
+    "openai_today_cost",
+    "openai_today_tokens",
+    "claude_five_hour_percent",
+    "claude_weekly_percent",
+    "codex_five_hour_percent",
+    "codex_weekly_percent",
+    "supabase_usage_health",
+    "cloudflare_month_to_date",
+];
+export const LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
+    "context_percent",
+    "last_request_tokens",
+    "total_tokens",
+    "five_hour_limit_percent",
+    "weekly_limit_percent",
+    "five_hour_remaining_tokens",
+    "weekly_remaining_tokens",
+    "context_tokens",
+    "input_tokens",
+    "output_tokens",
+    "cache_tokens",
+    "reasoning_tokens",
+    "sessions",
+    "turns",
+    "tool_calls",
+    "log_files",
+];
+export const DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS = [
+    "month_forecast",
+    "today_live_cost",
+    "risk_high_count",
+    "stale_connection_count",
+    "openai_today_tokens",
+    "codex_five_hour_percent",
+];
+export const DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
+    "context_percent",
+    "last_request_tokens",
+    "total_tokens",
+];
+export const DEFAULT_NOTIFICATION_THRESHOLD_RULES = [
+    {
+        widgetKey: "risk_high_count",
+        operator: "gte",
+        value: 1,
+        cooldownMinutes: 60,
+    },
+    {
+        widgetKey: "today_live_cost",
+        operator: "gte",
+        value: 10,
+        cooldownMinutes: 180,
+    },
+    {
+        widgetKey: "codex_weekly_percent",
+        operator: "gte",
+        value: 90,
+        cooldownMinutes: 360,
+    },
+];
+export const DEFAULT_NOTIFICATION_PREFERENCES = {
+    enabled: true,
+    digestEnabled: true,
+    digestInterval: "daily",
+    quietHours: {
+        start: "22:00",
+        end: "08:00",
+    },
+    selectedWidgets: DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS,
+    thresholdRules: DEFAULT_NOTIFICATION_THRESHOLD_RULES,
+    desktopEnabled: false,
+    dashboard: {
+        localCliMetricKeys: DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS,
+    },
+    hud: {
+        alwaysOnTop: true,
+        fontScale: 0.95,
+        opacity: 0.94,
+        selectedWidgets: DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS,
+    },
+};
+export function parseNotificationPreferences(value) {
+    if (!isRecord(value)) {
+        return cloneNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
+    }
+    const selectedWidgets = parseSelectedWidgets(value.selectedWidgets);
+    return {
+        enabled: typeof value.enabled === "boolean" ? value.enabled : DEFAULT_NOTIFICATION_PREFERENCES.enabled,
+        digestEnabled: typeof value.digestEnabled === "boolean"
+            ? value.digestEnabled
+            : DEFAULT_NOTIFICATION_PREFERENCES.digestEnabled,
+        digestInterval: parseDigestInterval(value.digestInterval),
+        quietHours: parseQuietHours(value.quietHours),
+        selectedWidgets,
+        thresholdRules: parseThresholdRules(value.thresholdRules),
+        desktopEnabled: typeof value.desktopEnabled === "boolean"
+            ? value.desktopEnabled
+            : DEFAULT_NOTIFICATION_PREFERENCES.desktopEnabled,
+        dashboard: parseDashboardDisplayPreferences(value.dashboard),
+        hud: parseHudPreferences(value.hud, selectedWidgets),
+    };
+}
+export function cloneNotificationPreferences(preferences) {
+    return {
+        enabled: preferences.enabled,
+        digestEnabled: preferences.digestEnabled,
+        digestInterval: preferences.digestInterval,
+        quietHours: {
+            ...preferences.quietHours,
+        },
+        selectedWidgets: [...preferences.selectedWidgets],
+        thresholdRules: preferences.thresholdRules.map((rule) => ({ ...rule })),
+        desktopEnabled: preferences.desktopEnabled,
+        dashboard: parseDashboardDisplayPreferences(preferences.dashboard),
+        hud: parseHudPreferences(preferences.hud),
+    };
+}
+function parseDashboardDisplayPreferences(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        localCliMetricKeys: parseLocalCliDashboardMetricKeys(record.localCliMetricKeys),
+    };
+}
+function parseHudPreferences(value, fallbackSelectedWidgets = DEFAULT_NOTIFICATION_PREFERENCES.hud.selectedWidgets) {
+    const record = isRecord(value) ? value : {};
+    return {
+        alwaysOnTop: typeof record.alwaysOnTop === "boolean"
+            ? record.alwaysOnTop
+            : DEFAULT_NOTIFICATION_PREFERENCES.hud.alwaysOnTop,
+        fontScale: clampNumber(record.fontScale, 0.8, 1.3, DEFAULT_NOTIFICATION_PREFERENCES.hud.fontScale),
+        opacity: clampNumber(record.opacity, 0, 1, DEFAULT_NOTIFICATION_PREFERENCES.hud.opacity),
+        selectedWidgets: parseSelectedWidgets(record.selectedWidgets, fallbackSelectedWidgets),
+    };
+}
+function parseLocalCliDashboardMetricKeys(value, fallbackMetricKeys = DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS) {
+    const metricKeys = new Set(LOCAL_CLI_DASHBOARD_METRIC_KEYS);
+    const selected = Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && metricKeys.has(item))
+        : [...fallbackMetricKeys];
+    return selected.length === 0 ? [...fallbackMetricKeys] : [...new Set(selected)];
+}
+function parseDigestInterval(value) {
+    return value === "six-hours" || value === "daily" || value === "weekly"
+        ? value
+        : DEFAULT_NOTIFICATION_PREFERENCES.digestInterval;
+}
+function parseQuietHours(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        start: parseTime(record.start, DEFAULT_NOTIFICATION_PREFERENCES.quietHours.start),
+        end: parseTime(record.end, DEFAULT_NOTIFICATION_PREFERENCES.quietHours.end),
+    };
+}
+function parseSelectedWidgets(value, fallbackSelectedWidgets = DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS) {
+    const widgetKeys = new Set(NOTIFICATION_WIDGET_KEYS);
+    const selected = Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && widgetKeys.has(item))
+        : [...fallbackSelectedWidgets];
+    return selected.length === 0 ? [...fallbackSelectedWidgets] : [...new Set(selected)];
+}
+function parseThresholdRules(value) {
+    if (!Array.isArray(value)) {
+        return DEFAULT_NOTIFICATION_THRESHOLD_RULES.map((rule) => ({ ...rule }));
+    }
+    const rules = value
+        .map((item) => isRecord(item) ? item : null)
+        .filter((item) => item !== null)
+        .map((item) => {
+        const widgetKey = parseWidgetKey(item.widgetKey);
+        const operator = parseOperator(item.operator);
+        const numericValue = parseNonNegativeNumber(item.value);
+        const cooldownMinutes = parseNonNegativeNumber(item.cooldownMinutes);
+        if (widgetKey === null || operator === null || numericValue === null || cooldownMinutes === null) {
+            return null;
+        }
+        return {
+            widgetKey,
+            operator,
+            value: numericValue,
+            cooldownMinutes,
+        };
+    })
+        .filter((item) => item !== null);
+    return rules.length === 0 ? DEFAULT_NOTIFICATION_THRESHOLD_RULES.map((rule) => ({ ...rule })) : rules;
+}
+function parseWidgetKey(value) {
+    return typeof value === "string" && NOTIFICATION_WIDGET_KEYS.includes(value)
+        ? value
+        : null;
+}
+function parseOperator(value) {
+    return value === "gte" || value === "lte" || value === "eq" ? value : null;
+}
+function parseNonNegativeNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    return Math.max(0, value);
+}
+function clampNumber(value, min, max, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, Math.round(value * 100) / 100));
+}
+function parseTime(value, fallback) {
+    return typeof value === "string" && /^\d{2}:\d{2}$/.test(value) ? value : fallback;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=notification-preferences-model.js.map

package/dist/packages/view-model/src/notification-preferences.d.ts

@@ -0,0 +1,6 @@
+import { type NotificationPreferenceFileOptions, type NotificationPreferences } from "./notification-preferences-model.js";
+export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, type DigestInterval, type DashboardDisplayPreferences, type LocalCliDashboardMetricKey, type NotificationPreferenceFileOptions, type NotificationPreferences, type NotificationThresholdRule, type NotificationWidgetKey, type ThresholdOperator, } from "./notification-preferences-model.js";
+export declare function readNotificationPreferencesFile(options?: NotificationPreferenceFileOptions): Promise<NotificationPreferences>;
+export declare function writeNotificationPreferencesFile(preferences: NotificationPreferences, options?: NotificationPreferenceFileOptions): Promise<NotificationPreferences>;
+export declare function resolveNotificationPreferencesPath(options?: NotificationPreferenceFileOptions): string;
+//# sourceMappingURL=notification-preferences.d.ts.map

package/dist/packages/view-model/src/notification-preferences.js

@@ -0,0 +1,36 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, parseNotificationPreferences, } from "./notification-preferences-model.js";
+export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, } from "./notification-preferences-model.js";
+const PREFERENCES_PATH_ENV = "MONEYSIREN_NOTIFICATION_PREFS_PATH";
+const DEFAULT_PREFERENCES_PATH = ".moneysiren/notification-preferences.json";
+export async function readNotificationPreferencesFile(options = {}) {
+    try {
+        const parsed = JSON.parse(await readFile(resolveNotificationPreferencesPath(options), "utf8"));
+        return parseNotificationPreferences(parsed);
+    }
+    catch {
+        return cloneNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
+    }
+}
+export async function writeNotificationPreferencesFile(preferences, options = {}) {
+    const normalized = parseNotificationPreferences(preferences);
+    const path = resolveNotificationPreferencesPath(options);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    return normalized;
+}
+export function resolveNotificationPreferencesPath(options = {}) {
+    if (options.path !== undefined && options.path.trim().length > 0) {
+        return resolveLocalPath(options.path, options.cwd);
+    }
+    const configuredPath = options.env?.[PREFERENCES_PATH_ENV]?.trim();
+    if (configuredPath !== undefined && configuredPath.length > 0) {
+        return resolveLocalPath(configuredPath, options.cwd);
+    }
+    return resolveLocalPath(DEFAULT_PREFERENCES_PATH, options.cwd);
+}
+function resolveLocalPath(path, cwd = process.cwd()) {
+    return isAbsolute(path) ? path : join(cwd, path);
+}
+//# sourceMappingURL=notification-preferences.js.map