@moneysiren/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/packages/view-model/src/sync-state.d.ts

@@ -0,0 +1,47 @@
+export type AggregateSyncStatus = "ok" | "partial" | "stale" | "error" | "empty";
+export type RiskSeverity = "info" | "warning" | "critical";
+export type SyncStateValue = "fresh" | "stale" | "error" | "not_configured" | "unavailable" | "locked";
+export type SyncErrorCode = "not_configured" | "auth_expired" | "permission_denied" | "rate_limited" | "timeout" | "network" | "upstream_unavailable" | "schema_changed" | "invalid_data" | "local_source_missing" | "local_io" | "internal";
+export interface SyncErrorView {
+    code: SyncErrorCode;
+    retryable: boolean;
+    userActionRequired: boolean;
+    message: string;
+}
+export interface ItemSyncView {
+    state: SyncStateValue;
+    observedAt: string | null;
+    lastAttemptAt: string | null;
+    lastSuccessAt: string | null;
+    freshUntil: string | null;
+    staleUntil: string | null;
+    ageSeconds: number | null;
+    source: string;
+    error: SyncErrorView | null;
+    lastRefreshFailed: boolean;
+}
+export declare function createSyncError(code: SyncErrorCode, message?: string): SyncErrorView;
+export declare function syncViewFromFreshness(options: {
+    freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked";
+    checkedAt: string | null;
+    generatedAt: string;
+    ttlSeconds?: number | null;
+    source: string;
+    message?: string | null;
+    lastAttemptAt?: string | null;
+    lastSuccessAt?: string | null;
+    freshUntil?: string | null;
+    staleUntil?: string | null;
+    lastRefreshFailed?: boolean;
+}): ItemSyncView;
+export declare function summarizeAggregateSync(items: readonly ItemSyncView[]): {
+    status: AggregateSyncStatus;
+    freshCount: number;
+    staleCount: number;
+    errorCount: number;
+    neutralCount: number;
+    lastSuccessAt: string | null;
+};
+export declare function syncStateFromFreshness(freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked"): SyncStateValue;
+export declare function isNeutralSyncState(state: SyncStateValue): boolean;
+//# sourceMappingURL=sync-state.d.ts.map

package/dist/packages/view-model/src/sync-state.js

@@ -0,0 +1,140 @@
+export function createSyncError(code, message) {
+    return {
+        code,
+        retryable: isRetryableSyncError(code),
+        userActionRequired: isUserActionRequiredSyncError(code),
+        message: sanitizeSyncMessage(message ?? defaultSyncErrorMessage(code)),
+    };
+}
+export function syncViewFromFreshness(options) {
+    const state = syncStateFromFreshness(options.freshness);
+    const observedAt = options.checkedAt;
+    const ageSeconds = observedAt === null
+        ? null
+        : Math.max(0, Math.floor((Date.parse(options.generatedAt) - Date.parse(observedAt)) / 1000));
+    const defaultFreshUntil = observedAt === null || options.ttlSeconds === null || options.ttlSeconds === undefined
+        ? null
+        : new Date(Date.parse(observedAt) + options.ttlSeconds * 1000).toISOString();
+    return {
+        state,
+        observedAt,
+        lastAttemptAt: options.lastAttemptAt ?? observedAt,
+        lastSuccessAt: options.lastSuccessAt ?? (state === "error" ? null : observedAt),
+        freshUntil: options.freshUntil ?? defaultFreshUntil,
+        staleUntil: options.staleUntil ?? null,
+        ageSeconds: Number.isFinite(ageSeconds) ? ageSeconds : null,
+        source: options.source,
+        error: state === "error" || state === "locked" || state === "not_configured"
+            ? createSyncError(errorCodeFromState(state, options.message), options.message ?? undefined)
+            : null,
+        lastRefreshFailed: options.lastRefreshFailed ?? state === "error",
+    };
+}
+export function summarizeAggregateSync(items) {
+    const actionable = items.filter((item) => !isNeutralSyncState(item.state));
+    const freshCount = actionable.filter((item) => item.state === "fresh").length;
+    const staleCount = actionable.filter((item) => item.state === "stale").length;
+    const errorCount = actionable.filter((item) => item.state === "error" || item.state === "locked").length;
+    const neutralCount = items.length - actionable.length;
+    const lastSuccessAt = latestIso(items.map((item) => item.lastSuccessAt).filter((value) => value !== null));
+    const status = actionable.length === 0
+        ? "empty"
+        : errorCount > 0 && (freshCount > 0 || staleCount > 0)
+            ? "partial"
+            : errorCount === actionable.length
+                ? "error"
+                : freshCount > 0 && staleCount > 0
+                    ? "partial"
+                    : staleCount === actionable.length
+                        ? "stale"
+                        : "ok";
+    return {
+        status,
+        freshCount,
+        staleCount,
+        errorCount,
+        neutralCount,
+        lastSuccessAt,
+    };
+}
+export function syncStateFromFreshness(freshness) {
+    if (freshness === "live") {
+        return "fresh";
+    }
+    if (freshness === "not_configured" || freshness === "unavailable" || freshness === "locked") {
+        return freshness;
+    }
+    return freshness;
+}
+export function isNeutralSyncState(state) {
+    return state === "not_configured" || state === "unavailable";
+}
+function errorCodeFromState(state, message) {
+    if (state === "not_configured") {
+        return "not_configured";
+    }
+    if (state === "locked") {
+        return "local_io";
+    }
+    if (message !== undefined && message !== null) {
+        const normalized = message.toLowerCase();
+        if (normalized.includes("permission") || normalized.includes("403")) {
+            return "permission_denied";
+        }
+        if (normalized.includes("401") || normalized.includes("expired")) {
+            return "auth_expired";
+        }
+        if (normalized.includes("429") || normalized.includes("rate limit")) {
+            return "rate_limited";
+        }
+        if (normalized.includes("timeout")) {
+            return "timeout";
+        }
+        if (normalized.includes("network") || normalized.includes("enotfound") || normalized.includes("econn")) {
+            return "network";
+        }
+    }
+    return "internal";
+}
+function isRetryableSyncError(code) {
+    return code === "rate_limited" || code === "timeout" || code === "network" || code === "upstream_unavailable";
+}
+function isUserActionRequiredSyncError(code) {
+    return code === "not_configured" ||
+        code === "auth_expired" ||
+        code === "permission_denied" ||
+        code === "local_source_missing" ||
+        code === "local_io";
+}
+function defaultSyncErrorMessage(code) {
+    if (code === "auth_expired") {
+        return "Login may have expired. Sign in again and retry.";
+    }
+    if (code === "permission_denied") {
+        return "Permission is not sufficient for this read-only check.";
+    }
+    if (code === "not_configured" || code === "local_source_missing") {
+        return "Local source or credential is not configured.";
+    }
+    if (code === "rate_limited") {
+        return "Provider request limit was reached. Retry later.";
+    }
+    if (code === "schema_changed") {
+        return "Provider response shape changed.";
+    }
+    return "Live sync failed.";
+}
+function sanitizeSyncMessage(value) {
+    return value
+        .replace(/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+/g, "[redacted]")
+        .replace(/\b(?:sk|sbp|xox[baprs])[-_][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/\bacct[_-][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/\b(?:proj|project|invoice)[_-][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[redacted]");
+}
+function latestIso(values) {
+    return values.length === 0
+        ? null
+        : [...values].sort((first, second) => second.localeCompare(first))[0] ?? null;
+}
+//# sourceMappingURL=sync-state.js.map

package/dist/packages/view-model/src/usage-progress.d.ts

@@ -0,0 +1,22 @@
+export interface UsageProgressView {
+    usedPercent: number | null;
+    remainingPercent: number | null;
+    warningAtPercent: number;
+    criticalAtPercent: number;
+}
+export type UsageProgressSeverity = "info" | "warning" | "critical";
+export declare function usageProgressFromUsedPercent(value: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressFromRemainingPercent(value: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressFromTokens(usedTokens: number | null | undefined, remainingTokens: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressSeverity(progress: UsageProgressView): UsageProgressSeverity;
+export declare function normalizePercent(value: number | null | undefined): number | null;
+//# sourceMappingURL=usage-progress.d.ts.map

package/dist/packages/view-model/src/usage-progress.js

@@ -0,0 +1,57 @@
+const DEFAULT_WARNING_AT_PERCENT = 80;
+const DEFAULT_CRITICAL_AT_PERCENT = 95;
+export function usageProgressFromUsedPercent(value, thresholds = {}) {
+    const usedPercent = normalizePercent(value);
+    const warningAtPercent = thresholds.warningAtPercent ?? DEFAULT_WARNING_AT_PERCENT;
+    const criticalAtPercent = thresholds.criticalAtPercent ?? DEFAULT_CRITICAL_AT_PERCENT;
+    return {
+        usedPercent,
+        remainingPercent: usedPercent === null ? null : clampPercent(100 - usedPercent),
+        warningAtPercent,
+        criticalAtPercent,
+    };
+}
+export function usageProgressFromRemainingPercent(value, thresholds = {}) {
+    const remainingPercent = normalizePercent(value);
+    const warningAtPercent = thresholds.warningAtPercent ?? DEFAULT_WARNING_AT_PERCENT;
+    const criticalAtPercent = thresholds.criticalAtPercent ?? DEFAULT_CRITICAL_AT_PERCENT;
+    return {
+        usedPercent: remainingPercent === null ? null : clampPercent(100 - remainingPercent),
+        remainingPercent,
+        warningAtPercent,
+        criticalAtPercent,
+    };
+}
+export function usageProgressFromTokens(usedTokens, remainingTokens, thresholds = {}) {
+    const used = normalizeNonNegativeNumber(usedTokens);
+    const remaining = normalizeNonNegativeNumber(remainingTokens);
+    if (used === null || remaining === null) {
+        return usageProgressFromUsedPercent(null, thresholds);
+    }
+    const total = used + remaining;
+    return usageProgressFromUsedPercent(total <= 0 ? null : (used / total) * 100, thresholds);
+}
+export function usageProgressSeverity(progress) {
+    if (progress.usedPercent === null) {
+        return "info";
+    }
+    if (progress.usedPercent >= progress.criticalAtPercent) {
+        return "critical";
+    }
+    if (progress.usedPercent >= progress.warningAtPercent) {
+        return "warning";
+    }
+    return "info";
+}
+export function normalizePercent(value) {
+    return value === null || value === undefined || !Number.isFinite(value)
+        ? null
+        : clampPercent(value);
+}
+function normalizeNonNegativeNumber(value) {
+    return value === null || value === undefined || !Number.isFinite(value) || value < 0 ? null : value;
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Number(value.toFixed(2))));
+}
+//# sourceMappingURL=usage-progress.js.map

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

@@ -112,6 +112,15 @@ export interface TodayLiveProviderInput {
     providerKey: string;
     displayName: string;
     checkedAt: string | null;
+    expiresAt?: string | null;
+    ttlSeconds?: number;
+    lastAttemptAt?: string | null;
+    lastSuccessAt?: string | null;
+    freshUntil?: string | null;
+    staleUntil?: string | null;
+    lastRefreshFailed?: boolean;
+    revision?: number;
+    message?: string;
     freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked";
     confidence: "high" | "medium" | "low" | "none";
     todayLiveAmountMinor: number | null;
@@ -126,6 +135,11 @@ export interface TodayLiveMetric {
     key: string;
     value: number;
     unit: string;
+    resetAt?: string;
+    resetAtLatest?: string;
+    itemKey?: string;
+    accuracy?: "exact" | "estimated" | "bounded" | "unknown";
+    source?: string;
 }
 export interface NotificationDigest extends LocalSafeEnvelope {
     title: string;
@@ -139,6 +153,14 @@ export interface NotificationDigestItem {
     severity: ViewModelRiskSeverity;
     label: string;
     value: string;
+    numericValue?: number;
+    unit?: string;
+    usedPercent?: number;
+    remainingPercent?: number;
+    resetAt?: string;
+    resetAtLatest?: string;
+    providerKey?: string;
+    accuracy?: "exact" | "estimated" | "bounded" | "unknown";
     freshness?: TodayLiveProviderView["freshness"];
     confidence?: TodayLiveProviderView["confidence"];
     clickPath?: string;

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

@@ -4,8 +4,10 @@ const OPENAI_PROVIDER_KEY = "openai";
 const AWS_PROVIDER_KEY = "aws";
 const SUPABASE_PROVIDER_KEY = "supabase";
 const CLOUDFLARE_PROVIDER_KEY = "cloudflare";
+const CODEX_APP_PROVIDER_KEY = "codex-app";
 const CODEX_CLI_PROVIDER_KEY = "codex-cli";
 const CLAUDE_CLI_PROVIDER_KEY = "claude-cli";
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const SENSITIVE_TEXT_PATTERN = /(https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+|\b(?:sk|sbp|xox[baprs])[-_][A-Za-z0-9_-]+\b|\bacct[_-][A-Za-z0-9_-]+\b|\b(?:proj|project)[_-][A-Za-z0-9_-]+\b|\b(?:in|invoice)[_-][A-Za-z0-9_-]+\b|[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,})/gi;
 const EMPTY_STORE = {
     providers: [],
@@ -115,10 +117,23 @@ export function buildTodayLiveView(store, options) {
             ...provider,
             providerKey: safeText(provider.providerKey),
             displayName: safeText(provider.displayName),
+            ...(provider.expiresAt === undefined ? {} : { expiresAt: provider.expiresAt }),
+            ...(provider.lastAttemptAt === undefined ? {} : { lastAttemptAt: provider.lastAttemptAt }),
+            ...(provider.lastSuccessAt === undefined ? {} : { lastSuccessAt: provider.lastSuccessAt }),
+            ...(provider.freshUntil === undefined ? {} : { freshUntil: provider.freshUntil }),
+            ...(provider.staleUntil === undefined ? {} : { staleUntil: provider.staleUntil }),
+            ...(provider.lastRefreshFailed === undefined ? {} : { lastRefreshFailed: provider.lastRefreshFailed }),
+            ...(provider.revision === undefined ? {} : { revision: provider.revision }),
+            ...(provider.message === undefined ? {} : { message: safeText(provider.message) }),
             metrics: (provider.metrics ?? []).map((metric) => ({
                 key: safeText(metric.key),
                 value: metric.value,
                 unit: safeText(metric.unit),
+                ...(metric.resetAt === undefined ? {} : { resetAt: safeText(metric.resetAt) }),
+                ...(metric.resetAtLatest === undefined ? {} : { resetAtLatest: safeText(metric.resetAtLatest) }),
+                ...(metric.itemKey === undefined ? {} : { itemKey: safeText(metric.itemKey) }),
+                ...(metric.accuracy === undefined ? {} : { accuracy: metric.accuracy }),
+                ...(metric.source === undefined ? {} : { source: safeText(metric.source) }),
             })),
         }));
     const includedProviders = providers.filter((provider) => provider.included && provider.todayLiveAmountMinor !== null);
@@ -387,6 +402,8 @@ function buildDigestItems(overview, todayLive, alerts) {
             usedTokensMetricKey: "weekly_tokens",
             clickPath: "/ko/services/codex-cli",
         }),
+        codexResetCreditCountItem(todayLive),
+        codexResetCreditExpiryItem(todayLive),
         {
             widgetKey: "supabase_usage_health",
             kind: "health",
@@ -425,6 +442,13 @@ function cliRemainingPercentItem(options) {
         severity: remainingPercentSeverity(percent),
         label: options.label,
         value: percent === null ? "Not available" : formatPercent(percent),
+        ...(percent === null ? {} : {
+            numericValue: percent,
+            unit: "percent",
+            remainingPercent: percent,
+            usedPercent: clampPercent(100 - percent),
+        }),
+        providerKey: options.providerKey,
         ...(firstProvider === undefined
             ? {}
             : {
@@ -434,6 +458,68 @@ function cliRemainingPercentItem(options) {
         clickPath: options.clickPath,
     };
 }
+function codexResetCreditCountItem(todayLive) {
+    const providers = [
+        ...todayProviders(todayLive, CODEX_APP_PROVIDER_KEY),
+        ...todayProviders(todayLive, CODEX_CLI_PROVIDER_KEY),
+    ];
+    const firstProvider = providers[0];
+    const metricEntry = firstMetricEntry(providers, "usage_reset_credits");
+    const count = metricEntry?.metric.value ?? null;
+    const clickProviderKey = metricEntry?.provider.providerKey ?? CODEX_CLI_PROVIDER_KEY;
+    return {
+        widgetKey: "codex_reset_credit_count",
+        kind: "usage",
+        severity: "info",
+        label: "Codex reset credits",
+        value: count === null ? "Not available" : formatCount(count),
+        ...(count === null ? {} : {
+            numericValue: count,
+            unit: "count",
+        }),
+        ...(metricEntry === undefined ? {} : { providerKey: metricEntry.provider.providerKey }),
+        ...(firstProvider === undefined
+            ? {}
+            : {
+                freshness: firstProvider.freshness,
+                confidence: firstProvider.confidence,
+            }),
+        clickPath: `/ko/services/${clickProviderKey}`,
+    };
+}
+function codexResetCreditExpiryItem(todayLive) {
+    const providers = [
+        ...todayProviders(todayLive, CODEX_APP_PROVIDER_KEY),
+        ...todayProviders(todayLive, CODEX_CLI_PROVIDER_KEY),
+    ];
+    const firstProvider = providers[0];
+    const exactExpiry = earliestMetricResetAt(providers, "usage_reset_credit");
+    const estimatedExpiry = earliestMetricResetAt(providers, "usage_reset_credit_estimate");
+    const earliestExpiry = exactExpiry ?? estimatedExpiry;
+    const metric = earliestResetCreditMetric(providers, exactExpiry === null ? "usage_reset_credit_estimate" : "usage_reset_credit", earliestExpiry);
+    const metricProviderKey = metric === undefined ? undefined : providerForMetric(providers, metric);
+    const daysUntil = earliestExpiry === null
+        ? null
+        : Math.ceil((Date.parse(earliestExpiry) - Date.parse(todayLive.generatedAt)) / MS_PER_DAY);
+    return {
+        widgetKey: "codex_reset_credit_expiry",
+        kind: "usage",
+        severity: resetCreditExpirySeverity(daysUntil),
+        label: "Codex reset credit expiry",
+        value: resetCreditExpiryValue(daysUntil),
+        ...(earliestExpiry === null ? {} : { resetAt: earliestExpiry }),
+        ...(metric?.resetAtLatest === undefined ? {} : { resetAtLatest: metric.resetAtLatest }),
+        ...(metric?.accuracy === undefined ? {} : { accuracy: metric.accuracy }),
+        ...(metricProviderKey === undefined ? {} : { providerKey: metricProviderKey }),
+        ...(firstProvider === undefined
+            ? {}
+            : {
+                freshness: firstProvider.freshness,
+                confidence: firstProvider.confidence,
+            }),
+        clickPath: "/ko/services/codex-cli",
+    };
+}
 async function resolveStore(options) {
     if (options.store !== undefined) {
         return options.store;
@@ -529,6 +615,33 @@ function metricFirst(providers, metricKey) {
     }
     return null;
 }
+function firstMetricEntry(providers, metricKey) {
+    for (const provider of providers) {
+        const metric = provider.metrics.find((item) => item.key === metricKey);
+        if (metric !== undefined) {
+            return { provider, metric };
+        }
+    }
+    return undefined;
+}
+function earliestMetricResetAt(providers, metricKey) {
+    const values = providers.flatMap((provider) => provider.metrics
+        .filter((metric) => metric.key === metricKey && metric.resetAt !== undefined)
+        .map((metric) => metric.resetAt)
+        .filter((value) => Number.isFinite(Date.parse(value))));
+    return values.sort((first, second) => Date.parse(first) - Date.parse(second))[0] ?? null;
+}
+function earliestResetCreditMetric(providers, metricKey, resetAt) {
+    if (resetAt === null) {
+        return undefined;
+    }
+    return providers
+        .flatMap((provider) => provider.metrics)
+        .find((metric) => metric.key === metricKey && metric.resetAt === resetAt);
+}
+function providerForMetric(providers, target) {
+    return providers.find((provider) => provider.metrics.some((metric) => metric === target))?.providerKey;
+}
 function remainingPercentFromMetrics(providers, remainingTokensMetricKey, usedTokensMetricKey, usedPercentMetricKey) {
     const remainingTokens = metricSum(providers, remainingTokensMetricKey);
     const usedTokens = metricSum(providers, usedTokensMetricKey);
@@ -541,6 +654,30 @@ function remainingPercentFromMetrics(providers, remainingTokensMetricKey, usedTo
     const usedPercent = metricFirst(providers, usedPercentMetricKey);
     return usedPercent === null ? null : clampPercent(100 - usedPercent);
 }
+function resetCreditExpirySeverity(daysUntil) {
+    if (daysUntil === null) {
+        return "info";
+    }
+    if (daysUntil <= 1) {
+        return "critical";
+    }
+    if (daysUntil <= 7) {
+        return "warning";
+    }
+    return "info";
+}
+function resetCreditExpiryValue(daysUntil) {
+    if (daysUntil === null) {
+        return "Not available";
+    }
+    if (daysUntil <= 0) {
+        return "May expire now";
+    }
+    if (daysUntil === 1) {
+        return "May expire within 1 day";
+    }
+    return `May expire within ${daysUntil} days`;
+}
 function providerRiskSeverity(provider) {
     if (provider?.riskLevel === "critical") {
         return "critical";
@@ -662,6 +799,11 @@ function formatTokens(tokens) {
         maximumFractionDigits: 0,
     }).format(tokens);
 }
+function formatCount(value) {
+    return new Intl.NumberFormat("en-US", {
+        maximumFractionDigits: 0,
+    }).format(value);
+}
 function formatPercent(percent) {
     const rounded = Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(1);
     return `${rounded}%`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneysiren/cli",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.11",
   "description": "Local-first cloud/SaaS usage, status, and expected billing CLI for MoneySiren.",
   "private": false,
   "license": "MIT",
@@ -10,7 +10,8 @@
     "node": ">=20.11.0"
   },
   "bin": {
-    "moneysiren": "dist/apps/cli/src/index.js"
+    "moneysiren": "dist/apps/cli/src/index.js",
+    "msiren": "dist/apps/cli/src/index.js"
   },
   "main": "dist/apps/cli/src/cli.js",
   "types": "dist/apps/cli/src/cli.d.ts",