@moneysiren/cli 0.1.0-alpha.0

package/dist/apps/cli/src/slash.js

@@ -0,0 +1,202 @@
+const SUPPORTED_SYNC_PROVIDERS = ["mock", "aws", "openai", "supabase", "cloudflare"];
+export function parseSlashInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(/\s+/);
+}
+export function isSlashQuit(args) {
+    return args.length === 1 && args[0]?.toLowerCase() === "/quit";
+}
+export function resolveSlashCommand(args) {
+    const [rawCommand, ...rest] = args;
+    if (rawCommand === undefined || !rawCommand.startsWith("/")) {
+        return {
+            kind: "error",
+            message: "Slash commands must start with `/`.",
+            usage: "Run `moneysiren /help` for slash usage.",
+        };
+    }
+    const command = rawCommand.toLowerCase();
+    if (command === "/help") {
+        return noExtraArgs(command, rest, ["--help"]);
+    }
+    if (command === "/version") {
+        return noExtraArgs(command, rest, ["--version"]);
+    }
+    if (command === "/doctor") {
+        return noExtraArgs(command, rest, ["doctor"]);
+    }
+    if (command === "/install") {
+        return resolveInstallSlash(rest);
+    }
+    if (command === "/modes") {
+        return noExtraArgs(command, rest, ["modes"]);
+    }
+    if (command === "/init") {
+        return noExtraArgs(command, rest, ["init"]);
+    }
+    if (command === "/dashboard") {
+        return resolveDashboardSlash(rest);
+    }
+    if (command === "/summary") {
+        return resolveSummarySlash(rest);
+    }
+    if (command === "/notify") {
+        return resolveNotifySlash(rest);
+    }
+    if (command === "/desktop") {
+        return resolveDesktopSlash(rest);
+    }
+    if (command === "/sync") {
+        return resolveSyncSlash(rest);
+    }
+    if (command === "/report") {
+        return resolveReportSlash(rest);
+    }
+    if (command === "/theme") {
+        return resolveThemeSlash(rest);
+    }
+    if (command === "/quit") {
+        if (rest.length === 0) {
+            return {
+                kind: "quit",
+            };
+        }
+        return invalidUsage(command, "Usage: moneysiren /quit");
+    }
+    return {
+        kind: "error",
+        message: `Unknown slash command: ${formatSlashCommand(args)}`,
+        usage: "Run `moneysiren /help` for slash usage.",
+    };
+}
+function noExtraArgs(command, rest, mappedArgs) {
+    if (rest.length > 0) {
+        return invalidUsage(command, `Usage: moneysiren ${command}`);
+    }
+    return {
+        kind: "dispatch",
+        args: mappedArgs,
+    };
+}
+function resolveDashboardSlash(rest) {
+    if (rest.length === 0) {
+        return {
+            kind: "dispatch",
+            args: ["dashboard", "check"],
+        };
+    }
+    const [subcommand, ...subcommandRest] = rest;
+    if (subcommand === "check") {
+        return {
+            kind: "dispatch",
+            args: ["dashboard", "check", ...subcommandRest],
+        };
+    }
+    return invalidUsage("/dashboard", "Usage: moneysiren /dashboard [check]");
+}
+function resolveInstallSlash(rest) {
+    if (rest.length === 0) {
+        return {
+            kind: "dispatch",
+            args: ["install"],
+        };
+    }
+    if (rest.length === 1 && rest[0] === "status") {
+        return {
+            kind: "dispatch",
+            args: ["install", "--status"],
+        };
+    }
+    return {
+        kind: "dispatch",
+        args: ["install", ...rest],
+    };
+}
+function resolveSyncSlash(rest) {
+    const [provider, ...extra] = rest;
+    if (provider === undefined || extra.length > 0 || !isSupportedSyncProvider(provider)) {
+        return invalidUsage("/sync", "Usage: moneysiren /sync <mock|aws|openai|supabase|cloudflare>");
+    }
+    return {
+        kind: "dispatch",
+        args: ["sync", "--provider", provider],
+    };
+}
+function resolveSummarySlash(rest) {
+    if (rest.length !== 1 || rest[0] !== "json") {
+        return invalidUsage("/summary", "Usage: moneysiren /summary json");
+    }
+    return {
+        kind: "dispatch",
+        args: ["summary", "--json"],
+    };
+}
+function resolveNotifySlash(rest) {
+    if (rest.length === 1 && rest[0] === "dry-run") {
+        return {
+            kind: "dispatch",
+            args: ["notify", "once", "--dry-run"],
+        };
+    }
+    if (rest.length === 1 && rest[0] === "prefs") {
+        return {
+            kind: "dispatch",
+            args: ["notify", "prefs", "list"],
+        };
+    }
+    return invalidUsage("/notify", "Usage: moneysiren /notify <dry-run|prefs>");
+}
+function resolveDesktopSlash(rest) {
+    if (rest.length !== 1 || rest[0] !== "status") {
+        return invalidUsage("/desktop", "Usage: moneysiren /desktop status");
+    }
+    return {
+        kind: "dispatch",
+        args: ["desktop", "status"],
+    };
+}
+function resolveReportSlash(rest) {
+    if (rest.length !== 1 || rest[0] !== "ko") {
+        return invalidUsage("/report", "Usage: moneysiren /report ko");
+    }
+    return {
+        kind: "dispatch",
+        args: ["report", "daily", "--lang", "ko"],
+    };
+}
+function resolveThemeSlash(rest) {
+    const [subcommand, ...extra] = rest;
+    if (subcommand === "preview" || subcommand === "image-prompt") {
+        if (extra.length > 0) {
+            return invalidUsage("/theme", "Usage: moneysiren /theme <preview|image-prompt|image-generate>");
+        }
+        return {
+            kind: "dispatch",
+            args: ["theme", subcommand],
+        };
+    }
+    if (subcommand === "image-generate") {
+        return {
+            kind: "dispatch",
+            args: ["theme", subcommand, ...extra],
+        };
+    }
+    return invalidUsage("/theme", "Usage: moneysiren /theme <preview|image-prompt|image-generate>");
+}
+function invalidUsage(command, usage) {
+    return {
+        kind: "error",
+        message: `Invalid slash command usage: ${command}`,
+        usage,
+    };
+}
+function isSupportedSyncProvider(provider) {
+    return SUPPORTED_SYNC_PROVIDERS.includes(provider);
+}
+function formatSlashCommand(args) {
+    return args.join(" ");
+}
+//# sourceMappingURL=slash.js.map

package/dist/apps/cli/src/summary-model.d.ts

@@ -0,0 +1,51 @@
+import { type LocalAlertRecord } from "../../../packages/db/src/index.js";
+import type { CliExecutionContext } from "./cli.js";
+export interface SanitizedSummary {
+    generatedAt: string;
+    database: {
+        path: string;
+        available: boolean;
+    };
+    secretsReturned: false;
+    providerCount: number;
+    providers: SanitizedProviderSummary[];
+    totals: {
+        estimatedAmountMinorByCurrency: CurrencyTotal[];
+        alertCount: number;
+        health: "ok" | "degraded" | "down" | "unknown";
+    };
+}
+export interface SanitizedProviderSummary {
+    key: string;
+    displayName: string;
+    lastCollectedAt: string | null;
+    usageSnapshotCount: number;
+    billingSnapshotCount: number;
+    healthSnapshotCount: number;
+    costEstimateCount: number;
+    alertCount: number;
+    health: "ok" | "degraded" | "down" | "unknown";
+    estimatedCost: {
+        amountMinor: number;
+        currency: string;
+        confidence: "low" | "medium" | "high";
+    } | null;
+}
+export interface NotificationDigest {
+    generatedAt: string;
+    secretsReturned: false;
+    providerCount: number;
+    estimatedAmountMinorByCurrency: CurrencyTotal[];
+    alertCount: number;
+    criticalAlertCount: number;
+    health: "ok" | "degraded" | "down" | "unknown";
+}
+interface CurrencyTotal {
+    currency: string;
+    amountMinor: number;
+}
+export declare function readSanitizedSummary(context: CliExecutionContext): Promise<SanitizedSummary>;
+export declare function buildNotificationDigest(summary: SanitizedSummary, alerts?: readonly LocalAlertRecord[]): NotificationDigest;
+export declare function readSanitizedNotificationDigest(context: CliExecutionContext): Promise<NotificationDigest>;
+export {};
+//# sourceMappingURL=summary-model.d.ts.map

package/dist/apps/cli/src/summary-model.js

@@ -0,0 +1,136 @@
+import { stat } from "node:fs/promises";
+import { readLocalStore, } from "../../../packages/db/src/index.js";
+import { loadCliConfig, resolveDbPath } from "./commands/shared.js";
+export async function readSanitizedSummary(context) {
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    const generatedAt = context.now().toISOString();
+    if (!await pathExists(dbPath)) {
+        return {
+            generatedAt,
+            database: {
+                path: config.dbPath,
+                available: false,
+            },
+            secretsReturned: false,
+            providerCount: 0,
+            providers: [],
+            totals: {
+                estimatedAmountMinorByCurrency: [],
+                alertCount: 0,
+                health: "unknown",
+            },
+        };
+    }
+    const store = await readLocalStore({ dbPath });
+    const providers = store.providers.map((provider) => {
+        const usageSnapshots = store.usageSnapshots.filter((snapshot) => snapshot.providerKey === provider.key);
+        const billingSnapshots = store.billingSnapshots.filter((snapshot) => snapshot.providerKey === provider.key);
+        const healthSnapshots = store.serviceHealthSnapshots.filter((snapshot) => snapshot.providerKey === provider.key);
+        const costEstimates = store.costEstimates.filter((snapshot) => snapshot.providerKey === provider.key);
+        const alerts = store.alerts.filter((alert) => alert.providerKey === provider.key);
+        const latestCostEstimate = latestByCollectedAt(costEstimates);
+        return {
+            key: provider.key,
+            displayName: provider.displayName,
+            lastCollectedAt: latestTimestamp([
+                ...usageSnapshots.map((snapshot) => snapshot.collectedAt),
+                ...billingSnapshots.map((snapshot) => snapshot.collectedAt),
+                ...healthSnapshots.map((snapshot) => snapshot.collectedAt),
+                ...costEstimates.map((snapshot) => snapshot.collectedAt),
+            ]),
+            usageSnapshotCount: usageSnapshots.length,
+            billingSnapshotCount: billingSnapshots.length,
+            healthSnapshotCount: healthSnapshots.length,
+            costEstimateCount: costEstimates.length,
+            alertCount: alerts.length,
+            health: summarizeHealth(healthSnapshots),
+            estimatedCost: latestCostEstimate === undefined
+                ? null
+                : {
+                    amountMinor: latestCostEstimate.estimatedAmountMinor,
+                    currency: latestCostEstimate.currency,
+                    confidence: latestCostEstimate.confidence,
+                },
+        };
+    });
+    return {
+        generatedAt,
+        database: {
+            path: config.dbPath,
+            available: true,
+        },
+        secretsReturned: false,
+        providerCount: providers.length,
+        providers,
+        totals: {
+            estimatedAmountMinorByCurrency: summarizeCurrencyTotals(store.costEstimates),
+            alertCount: store.alerts.length,
+            health: summarizeProviderHealth(providers.map((provider) => provider.health)),
+        },
+    };
+}
+export function buildNotificationDigest(summary, alerts = []) {
+    return {
+        generatedAt: summary.generatedAt,
+        secretsReturned: false,
+        providerCount: summary.providerCount,
+        estimatedAmountMinorByCurrency: summary.totals.estimatedAmountMinorByCurrency,
+        alertCount: summary.totals.alertCount,
+        criticalAlertCount: alerts.filter((alert) => alert.severity === "critical").length,
+        health: summary.totals.health,
+    };
+}
+export async function readSanitizedNotificationDigest(context) {
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    const summary = await readSanitizedSummary(context);
+    if (!summary.database.available) {
+        return buildNotificationDigest(summary);
+    }
+    const store = await readLocalStore({ dbPath });
+    return buildNotificationDigest(summary, store.alerts);
+}
+function summarizeCurrencyTotals(costEstimates) {
+    const totals = new Map();
+    for (const estimate of costEstimates) {
+        totals.set(estimate.currency, (totals.get(estimate.currency) ?? 0) + estimate.estimatedAmountMinor);
+    }
+    return [...totals.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([currency, amountMinor]) => ({
+        currency,
+        amountMinor,
+    }));
+}
+function summarizeHealth(snapshots) {
+    return summarizeProviderHealth(snapshots.map((snapshot) => snapshot.status));
+}
+function summarizeProviderHealth(statuses) {
+    if (statuses.includes("down")) {
+        return "down";
+    }
+    if (statuses.includes("degraded")) {
+        return "degraded";
+    }
+    if (statuses.includes("unknown") || statuses.length === 0) {
+        return "unknown";
+    }
+    return "ok";
+}
+function latestByCollectedAt(items) {
+    return [...items].sort((left, right) => right.collectedAt.localeCompare(left.collectedAt))[0];
+}
+function latestTimestamp(timestamps) {
+    return [...timestamps].sort((left, right) => right.localeCompare(left))[0] ?? null;
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=summary-model.js.map

package/dist/apps/cli/src/theme.d.ts

@@ -0,0 +1,18 @@
+export interface Theme {
+    readonly colorEnabled: boolean;
+    readonly source: string;
+    brand(text: string): string;
+    heading(text: string): string;
+    command(text: string): string;
+    muted(text: string): string;
+    warning(text: string): string;
+}
+interface ThemeOptions {
+    cwd?: string;
+    env: Record<string, string | undefined>;
+    stdoutIsTTY: boolean;
+}
+export declare function createTheme(options: ThemeOptions): Theme;
+export declare function shouldUseColor(options: ThemeOptions): boolean;
+export {};
+//# sourceMappingURL=theme.d.ts.map

package/dist/apps/cli/src/theme.js

@@ -0,0 +1,118 @@
+import { readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+const DEFAULT_PALETTE = {
+    brand: "1;36",
+    heading: "1;37",
+    command: "32",
+    muted: "90",
+    warning: "33",
+};
+const IMAGE_DASHBOARD_PALETTE = {
+    brand: "1;38;5;30",
+    heading: "1;38;5;231",
+    command: "38;5;35",
+    muted: "38;5;244",
+    warning: "38;5;214",
+};
+export function createTheme(options) {
+    const colorEnabled = shouldUseColor(options);
+    const resolved = resolveThemePalette(options);
+    return {
+        colorEnabled,
+        source: resolved.source,
+        brand: style(colorEnabled, resolved.palette.brand),
+        heading: style(colorEnabled, resolved.palette.heading),
+        command: style(colorEnabled, resolved.palette.command),
+        muted: style(colorEnabled, resolved.palette.muted),
+        warning: style(colorEnabled, resolved.palette.warning),
+    };
+}
+export function shouldUseColor(options) {
+    if (hasEnvValue(options.env.NO_COLOR)) {
+        return false;
+    }
+    const forcedColor = parseForceColor(options.env.FORCE_COLOR);
+    if (forcedColor !== undefined) {
+        return forcedColor;
+    }
+    if (options.env.TERM?.toLowerCase() === "dumb") {
+        return false;
+    }
+    return options.stdoutIsTTY;
+}
+function style(colorEnabled, code) {
+    return (text) => {
+        if (!colorEnabled) {
+            return text;
+        }
+        return `\x1b[${code}m${text}\x1b[0m`;
+    };
+}
+function resolveThemePalette(options) {
+    const themeFile = options.env.MONEYSIREN_CLI_THEME_FILE?.trim();
+    if (themeFile !== undefined && themeFile.length > 0) {
+        const loaded = loadThemeFile(themeFile, options.cwd ?? process.cwd());
+        if (loaded !== null) {
+            return loaded;
+        }
+    }
+    if (options.env.MONEYSIREN_CLI_THEME?.trim().toLowerCase() === "image2-dashboard") {
+        return {
+            palette: IMAGE_DASHBOARD_PALETTE,
+            source: "image2-dashboard",
+        };
+    }
+    return {
+        palette: DEFAULT_PALETTE,
+        source: "default",
+    };
+}
+function loadThemeFile(path, cwd) {
+    try {
+        const absolutePath = isAbsolute(path) ? path : join(cwd, path);
+        const payload = JSON.parse(readFileSync(absolutePath, "utf8"));
+        return {
+            palette: {
+                ...DEFAULT_PALETTE,
+                ...sanitizePalette(payload.ansi ?? {}),
+            },
+            source: typeof payload.source === "string" && payload.source.trim().length > 0
+                ? payload.source.trim().slice(0, 80)
+                : `file:${path}`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizePalette(input) {
+    return Object.fromEntries(Object.entries(input)
+        .filter((entry) => isThemeRole(entry[0]) && isSafeAnsiCode(entry[1])));
+}
+function isThemeRole(value) {
+    return value === "brand" ||
+        value === "heading" ||
+        value === "command" ||
+        value === "muted" ||
+        value === "warning";
+}
+function isSafeAnsiCode(value) {
+    return typeof value === "string" && /^[0-9;]{1,32}$/.test(value);
+}
+function hasEnvValue(value) {
+    return value !== undefined && value.length > 0;
+}
+function parseForceColor(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "no") {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=theme.js.map

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

@@ -0,0 +1,3 @@
+export { DEFAULT_DB_PATH, PROVIDER_ENV_KEYS, type ConfiguredProvider, type ProviderConfig, type ProviderConfigMap, type SlackConfig, type MoneySirenConfig, type MoneySirenEnv, } from "./schema.js";
+export { loadMoneySirenConfig } from "./load.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export { DEFAULT_DB_PATH, PROVIDER_ENV_KEYS, } from "./schema.js";
+export { loadMoneySirenConfig } from "./load.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/config/src/load.d.ts

@@ -0,0 +1,3 @@
+import { type MoneySirenConfig, type MoneySirenEnv } from "./schema.js";
+export declare function loadMoneySirenConfig(env?: MoneySirenEnv): MoneySirenConfig;
+//# sourceMappingURL=load.d.ts.map

package/dist/packages/config/src/load.js

@@ -0,0 +1,77 @@
+import { DEFAULT_DB_PATH, PROVIDER_ENV_KEYS, } from "./schema.js";
+const TELEMETRY_OPT_IN_VALUES = new Set(["1", "true", "yes", "on", "enabled"]);
+export function loadMoneySirenConfig(env = process.env) {
+    const dbPath = loadDbPath(env);
+    const telemetryEnabled = loadTelemetryFlag(env);
+    return {
+        dbPath,
+        telemetryEnabled,
+        providers: loadProviders(env),
+        slack: {
+            webhookConfigured: isConfigured(env.SLACK_WEBHOOK_URL),
+            requiredEnvKey: "SLACK_WEBHOOK_URL",
+        },
+    };
+}
+function loadDbPath(env) {
+    const rawPath = env.MONEYSIREN_DB_PATH;
+    if (rawPath === undefined) {
+        return DEFAULT_DB_PATH;
+    }
+    const trimmedPath = rawPath.trim();
+    if (trimmedPath.length === 0) {
+        throw new Error("MONEYSIREN_DB_PATH must not be blank.");
+    }
+    return trimmedPath;
+}
+function loadTelemetryFlag(env) {
+    const rawTelemetry = env.MONEYSIREN_TELEMETRY;
+    if (rawTelemetry === undefined || rawTelemetry.trim().length === 0) {
+        return false;
+    }
+    const normalizedTelemetry = rawTelemetry.trim().toLowerCase();
+    if (TELEMETRY_OPT_IN_VALUES.has(normalizedTelemetry)) {
+        throw new Error("Telemetry is not supported in MoneySiren v0.1.");
+    }
+    return false;
+}
+function loadProviders(env) {
+    return {
+        aws: loadProviderConfig("aws", env),
+        openai: loadProviderConfig("openai", env),
+        supabase: loadProviderConfig("supabase", env),
+        cloudflare: loadProviderConfig("cloudflare", env),
+        gcp: loadProviderConfig("gcp", env),
+        azure: loadProviderConfig("azure", env),
+        oracle: loadProviderConfig("oracle", env),
+        anthropic: loadProviderConfig("anthropic", env),
+        gemini: loadProviderConfig("gemini", env),
+        vercel: loadProviderConfig("vercel", env),
+        "github-actions": loadProviderConfig("github-actions", env),
+        railway: loadProviderConfig("railway", env),
+        fly: loadProviderConfig("fly", env),
+        netlify: loadProviderConfig("netlify", env),
+        render: loadProviderConfig("render", env),
+        neon: loadProviderConfig("neon", env),
+        "mongodb-atlas": loadProviderConfig("mongodb-atlas", env),
+        datadog: loadProviderConfig("datadog", env),
+        sentry: loadProviderConfig("sentry", env),
+        "codex-cli": loadProviderConfig("codex-cli", env),
+        "claude-cli": loadProviderConfig("claude-cli", env),
+    };
+}
+function loadProviderConfig(provider, env) {
+    const requiredEnvKeys = PROVIDER_ENV_KEYS[provider];
+    const configuredEnvKeys = requiredEnvKeys.filter((envKey) => isConfigured(env[envKey]));
+    const missingEnvKeys = requiredEnvKeys.filter((envKey) => !isConfigured(env[envKey]));
+    return {
+        configured: requiredEnvKeys.length > 0 && missingEnvKeys.length === 0,
+        requiredEnvKeys,
+        configuredEnvKeys,
+        missingEnvKeys,
+    };
+}
+function isConfigured(value) {
+    return value !== undefined && value.trim().length > 0;
+}
+//# sourceMappingURL=load.js.map

package/dist/packages/config/src/schema.d.ts

@@ -0,0 +1,46 @@
+export declare const DEFAULT_DB_PATH = ".moneysiren/moneysiren.sqlite";
+export declare const PROVIDER_ENV_KEYS: {
+    readonly aws: readonly ["AWS_PROFILE"];
+    readonly openai: readonly ["OPENAI_ADMIN_KEY"];
+    readonly supabase: readonly ["SUPABASE_ACCESS_TOKEN"];
+    readonly cloudflare: readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_IDS"];
+    readonly gcp: readonly ["GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"];
+    readonly azure: readonly ["AZURE_TENANT_ID", "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_SUBSCRIPTION_ID"];
+    readonly oracle: readonly ["OCI_CONFIG_FILE", "OCI_PROFILE"];
+    readonly anthropic: readonly ["ANTHROPIC_ADMIN_KEY"];
+    readonly gemini: readonly ["GEMINI_API_KEY", "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"];
+    readonly vercel: readonly ["VERCEL_API_TOKEN"];
+    readonly "github-actions": readonly ["GITHUB_TOKEN"];
+    readonly railway: readonly ["RAILWAY_API_TOKEN"];
+    readonly fly: readonly ["FLY_ACCESS_TOKEN"];
+    readonly netlify: readonly ["NETLIFY_AUTH_TOKEN"];
+    readonly render: readonly ["RENDER_API_KEY"];
+    readonly neon: readonly ["NEON_API_KEY"];
+    readonly "mongodb-atlas": readonly ["MONGODB_ATLAS_PUBLIC_KEY", "MONGODB_ATLAS_PRIVATE_KEY", "MONGODB_ATLAS_ORG_ID"];
+    readonly datadog: readonly ["DATADOG_API_KEY", "DATADOG_APP_KEY", "DATADOG_SITE"];
+    readonly sentry: readonly ["SENTRY_AUTH_TOKEN", "SENTRY_ORG"];
+    readonly "codex-cli": readonly [];
+    readonly "claude-cli": readonly [];
+};
+export type ConfiguredProvider = keyof typeof PROVIDER_ENV_KEYS;
+export interface ProviderConfig {
+    configured: boolean;
+    requiredEnvKeys: readonly string[];
+    configuredEnvKeys: readonly string[];
+    missingEnvKeys: readonly string[];
+}
+export type ProviderConfigMap = {
+    readonly [Provider in ConfiguredProvider]: ProviderConfig;
+};
+export interface SlackConfig {
+    webhookConfigured: boolean;
+    requiredEnvKey: "SLACK_WEBHOOK_URL";
+}
+export interface MoneySirenConfig {
+    dbPath: string;
+    telemetryEnabled: false;
+    providers: ProviderConfigMap;
+    slack: SlackConfig;
+}
+export type MoneySirenEnv = Record<string, string | undefined>;
+//# sourceMappingURL=schema.d.ts.map