@moneysiren/cli 0.1.0-alpha.0

package/dist/packages/connectors/openai/src/index.js

@@ -0,0 +1,169 @@
+import { normalizeOpenAiUsageCosts, } from "./normalize.js";
+export { normalizeOpenAiUsageCosts, openAiAmountToMinorUnits, } from "./normalize.js";
+const OPENAI_API_BASE_URL = "https://api.openai.com";
+const EMPTY_OPENAI_SNAPSHOTS = {
+    usage: [],
+    billing: [],
+    serviceHealth: [],
+    costEstimates: [],
+};
+const defaultOpenAiUsageCostsTransport = {
+    async getJson(request) {
+        const url = new URL(request.path, OPENAI_API_BASE_URL);
+        for (const [key, value] of Object.entries(request.query)) {
+            if (isReadonlyStringArray(value)) {
+                for (const nestedValue of value) {
+                    url.searchParams.append(key, nestedValue);
+                }
+                continue;
+            }
+            url.searchParams.set(key, value);
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: request.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI Usage/Costs request failed with status ${response.status}.`);
+        }
+        return response.json();
+    },
+};
+export function createOpenAiUsageCostsClient(options) {
+    const adminKey = options.adminKey.trim();
+    if (adminKey.length === 0) {
+        throw new Error("OPENAI_ADMIN_KEY must not be blank.");
+    }
+    const transport = options.transport ?? defaultOpenAiUsageCostsTransport;
+    return {
+        async fetchUsageCosts(period) {
+            const headers = {
+                Authorization: `Bearer ${adminKey}`,
+            };
+            const usage = await fetchOpenAiPaginatedPage(transport, {
+                path: "/v1/organization/usage/completions",
+                query: {
+                    start_time: String(period.startTime),
+                    end_time: String(period.endTime),
+                    bucket_width: "1d",
+                    group_by: ["model"],
+                },
+                headers,
+            });
+            const costs = await fetchOpenAiPaginatedPage(transport, {
+                path: "/v1/organization/costs",
+                query: {
+                    start_time: String(period.startTime),
+                    end_time: String(period.endTime),
+                    bucket_width: "1d",
+                    group_by: ["line_item"],
+                },
+                headers,
+            });
+            return {
+                usage: usage,
+                costs: costs,
+            };
+        },
+    };
+}
+async function fetchOpenAiPaginatedPage(transport, request) {
+    const data = [];
+    const seenPageTokens = new Set();
+    let currentRequest = request;
+    let lastPage;
+    while (true) {
+        const page = await transport.getJson(currentRequest);
+        data.push(...(page.data ?? []));
+        lastPage = page;
+        if (page.has_more !== true) {
+            break;
+        }
+        const nextPage = requireOpenAiNextPageToken(page.next_page, request.path);
+        if (seenPageTokens.has(nextPage)) {
+            throw new Error(`OpenAI Usage/Costs ${request.path} pagination returned a repeated next_page token.`);
+        }
+        seenPageTokens.add(nextPage);
+        currentRequest = {
+            ...request,
+            query: {
+                ...request.query,
+                page: nextPage,
+            },
+        };
+    }
+    if (lastPage === undefined) {
+        throw new Error(`OpenAI Usage/Costs ${request.path} pagination did not return a page.`);
+    }
+    return {
+        ...lastPage,
+        data,
+    };
+}
+function requireOpenAiNextPageToken(value, path) {
+    const nextPage = value?.trim();
+    if (nextPage === undefined || nextPage.length === 0) {
+        throw new Error(`OpenAI Usage/Costs ${path} response has has_more=true without next_page.`);
+    }
+    return nextPage;
+}
+export function createStaticOpenAiUsageCostsClient(payload) {
+    return {
+        async fetchUsageCosts() {
+            return payload;
+        },
+    };
+}
+export function createOpenAiUsageCostsConnector(options) {
+    return {
+        kind: "openai",
+        displayName: "OpenAI Usage/Costs",
+        access: "read-only",
+        async collect(context) {
+            const collectedAt = context.now().toISOString();
+            const period = createCurrentOpenAiUsageCostsPeriod(context.now());
+            try {
+                const payload = await options.client.fetchUsageCosts(period);
+                return {
+                    collectedAt,
+                    status: "ok",
+                    snapshots: normalizeOpenAiUsageCosts({
+                        payload,
+                        collectedAt,
+                    }),
+                    alerts: [],
+                };
+            }
+            catch {
+                return {
+                    collectedAt,
+                    status: "error",
+                    snapshots: EMPTY_OPENAI_SNAPSHOTS,
+                    alerts: [
+                        {
+                            provider: "openai",
+                            createdAt: collectedAt,
+                            severity: "warning",
+                            category: "provider-sync",
+                            title: "OpenAI Usage/Costs sync failed",
+                            message: "OpenAI Usage/Costs request failed before normalized snapshots were collected.",
+                        },
+                    ],
+                    errors: ["OpenAI Usage/Costs request failed."],
+                };
+            }
+        },
+    };
+}
+export function createCurrentOpenAiUsageCostsPeriod(now) {
+    const start = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1) / 1000;
+    const end = Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1) / 1000;
+    return {
+        startTime: start,
+        endTime: end,
+    };
+}
+function isReadonlyStringArray(value) {
+    return Array.isArray(value);
+}
+//# sourceMappingURL=index.js.map

package/dist/packages/connectors/openai/src/normalize.d.ts

@@ -0,0 +1,91 @@
+declare const OPENAI_PROVIDER = "openai";
+export interface OpenAiUsageCostsPayload {
+    usage: OpenAiUsagePage;
+    costs: OpenAiCostsPage;
+}
+export interface OpenAiUsagePage {
+    object?: string;
+    data?: readonly OpenAiUsageBucket[];
+    has_more?: boolean;
+    next_page?: string | null;
+}
+export interface OpenAiUsageBucket {
+    object?: string;
+    start_time?: number;
+    end_time?: number;
+    results?: readonly OpenAiUsageResult[];
+}
+export interface OpenAiUsageResult {
+    object?: string;
+    model?: string;
+    input_tokens?: number;
+    output_tokens?: number;
+    num_model_requests?: number;
+}
+export interface OpenAiCostsPage {
+    object?: string;
+    data?: readonly OpenAiCostsBucket[];
+    has_more?: boolean;
+    next_page?: string | null;
+}
+export interface OpenAiCostsBucket {
+    object?: string;
+    start_time?: number;
+    end_time?: number;
+    results?: readonly OpenAiCostsResult[];
+}
+export interface OpenAiCostsResult {
+    object?: string;
+    amount?: OpenAiCostAmount;
+    line_item?: string;
+}
+export interface OpenAiCostAmount {
+    currency?: string;
+    value?: number | string;
+}
+export interface OpenAiNormalizedSnapshotBundle {
+    usage: readonly OpenAiUsageSnapshot[];
+    billing: readonly OpenAiBillingSnapshot[];
+    serviceHealth: readonly OpenAiServiceHealthSnapshot[];
+    costEstimates: readonly OpenAiCostEstimate[];
+}
+export interface OpenAiUsageSnapshot {
+    provider: typeof OPENAI_PROVIDER;
+    collectedAt: string;
+    service: string;
+    metric: "input_tokens" | "output_tokens" | "model_requests";
+    unit: "tokens" | "requests";
+    value: number;
+}
+export interface OpenAiBillingSnapshot {
+    provider: typeof OPENAI_PROVIDER;
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: number;
+    currency: string;
+    status: "estimated";
+}
+export interface OpenAiServiceHealthSnapshot {
+    provider: typeof OPENAI_PROVIDER;
+    collectedAt: string;
+    service: string;
+    status: "ok" | "degraded" | "down" | "unknown";
+}
+export interface OpenAiCostEstimate {
+    provider: typeof OPENAI_PROVIDER;
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: number;
+    currency: string;
+    confidence: "medium";
+}
+export interface NormalizeOpenAiUsageCostsInput {
+    payload: OpenAiUsageCostsPayload;
+    collectedAt: string;
+}
+export declare function normalizeOpenAiUsageCosts(input: NormalizeOpenAiUsageCostsInput): OpenAiNormalizedSnapshotBundle;
+export declare function openAiAmountToMinorUnits(amount: number | string): number;
+export {};
+//# sourceMappingURL=normalize.d.ts.map

package/dist/packages/connectors/openai/src/normalize.js

@@ -0,0 +1,180 @@
+const OPENAI_PROVIDER = "openai";
+export function normalizeOpenAiUsageCosts(input) {
+    return {
+        usage: normalizeUsage(input.payload.usage, input.collectedAt),
+        billing: normalizeBilling(input.payload.costs, input.collectedAt),
+        serviceHealth: [],
+        costEstimates: normalizeCostEstimates(input.payload.costs, input.collectedAt),
+    };
+}
+export function openAiAmountToMinorUnits(amount) {
+    const rawAmount = typeof amount === "number" ? String(requireFiniteNumber(amount, "OpenAI cost amount")) : amount;
+    const trimmed = rawAmount.trim();
+    const sign = trimmed.startsWith("-") ? -1n : 1n;
+    const unsigned = sign === -1n ? trimmed.slice(1) : trimmed;
+    if (!/^\d+(\.\d+)?$/.test(unsigned)) {
+        throw new Error(`OpenAI currency amount must be a decimal string or finite number: ${rawAmount}`);
+    }
+    const [wholePart = "0", fractionPart = ""] = unsigned.split(".");
+    const minorDigits = `${fractionPart}00`.slice(0, 2);
+    const roundingDigit = Number(`${fractionPart}000`.slice(2, 3));
+    let minorUnits = BigInt(wholePart) * 100n + BigInt(minorDigits);
+    if (roundingDigit >= 5) {
+        minorUnits += 1n;
+    }
+    const signedMinorUnits = minorUnits * sign;
+    const asNumber = Number(signedMinorUnits);
+    if (!Number.isSafeInteger(asNumber)) {
+        throw new Error(`OpenAI currency amount is outside safe integer range: ${rawAmount}`);
+    }
+    return asNumber;
+}
+function normalizeUsage(page, collectedAt) {
+    const usage = [];
+    for (const bucket of page.data ?? []) {
+        for (const result of bucket.results ?? []) {
+            const service = `${usageServicePrefix(result)}:${requireModel(result)}`;
+            const inputTokens = readOptionalFiniteNumber(result.input_tokens, `${service} input_tokens`);
+            const outputTokens = readOptionalFiniteNumber(result.output_tokens, `${service} output_tokens`);
+            const modelRequests = readOptionalFiniteNumber(result.num_model_requests, `${service} num_model_requests`);
+            if (inputTokens !== undefined) {
+                usage.push({
+                    provider: OPENAI_PROVIDER,
+                    collectedAt,
+                    service,
+                    metric: "input_tokens",
+                    unit: "tokens",
+                    value: inputTokens,
+                });
+            }
+            if (outputTokens !== undefined) {
+                usage.push({
+                    provider: OPENAI_PROVIDER,
+                    collectedAt,
+                    service,
+                    metric: "output_tokens",
+                    unit: "tokens",
+                    value: outputTokens,
+                });
+            }
+            if (modelRequests !== undefined) {
+                usage.push({
+                    provider: OPENAI_PROVIDER,
+                    collectedAt,
+                    service,
+                    metric: "model_requests",
+                    unit: "requests",
+                    value: modelRequests,
+                });
+            }
+        }
+    }
+    return usage;
+}
+function normalizeBilling(page, collectedAt) {
+    return normalizeCostBuckets(page, collectedAt).map((bucket) => ({
+        provider: OPENAI_PROVIDER,
+        collectedAt,
+        periodStart: bucket.periodStart,
+        periodEnd: bucket.periodEnd,
+        amountMinor: bucket.amountMinor,
+        currency: bucket.currency,
+        status: "estimated",
+    }));
+}
+function normalizeCostEstimates(page, collectedAt) {
+    return normalizeCostBuckets(page, collectedAt).map((bucket) => ({
+        provider: OPENAI_PROVIDER,
+        collectedAt,
+        periodStart: bucket.periodStart,
+        periodEnd: bucket.periodEnd,
+        estimatedAmountMinor: bucket.amountMinor,
+        currency: bucket.currency,
+        confidence: "medium",
+    }));
+}
+function normalizeCostBuckets(page, collectedAt) {
+    const buckets = [];
+    for (const bucket of page.data ?? []) {
+        const results = bucket.results ?? [];
+        if (results.length === 0) {
+            continue;
+        }
+        let amountMinor = 0;
+        let currency;
+        for (const result of results) {
+            const amount = requireAmount(result);
+            const resultCurrency = requireCurrency(amount);
+            if (currency !== undefined && currency !== resultCurrency) {
+                throw new Error("OpenAI costs bucket contains multiple currencies.");
+            }
+            currency = resultCurrency;
+            amountMinor += openAiAmountToMinorUnits(requireAmountValue(amount));
+        }
+        if (currency === undefined) {
+            continue;
+        }
+        buckets.push({
+            periodStart: unixSecondsToDateString(requireUnixSeconds(bucket.start_time, "OpenAI costs bucket start_time")),
+            periodEnd: unixSecondsToDateString(requireUnixSeconds(bucket.end_time, "OpenAI costs bucket end_time")),
+            amountMinor,
+            currency,
+        });
+    }
+    return buckets;
+}
+function usageServicePrefix(result) {
+    const objectName = result.object ?? "";
+    if (objectName.includes(".embeddings.")) {
+        return "embeddings";
+    }
+    return "completions";
+}
+function requireModel(result) {
+    const model = result.model?.trim();
+    if (model === undefined || model.length === 0) {
+        throw new Error("OpenAI usage result is missing model.");
+    }
+    return model;
+}
+function requireAmount(result) {
+    if (result.amount === undefined) {
+        throw new Error("OpenAI costs result is missing amount.");
+    }
+    return result.amount;
+}
+function requireCurrency(amount) {
+    const currency = amount.currency?.trim();
+    if (currency === undefined || currency.length === 0) {
+        throw new Error("OpenAI costs amount is missing currency.");
+    }
+    return currency.toUpperCase();
+}
+function requireAmountValue(amount) {
+    if (amount.value === undefined) {
+        throw new Error("OpenAI costs amount is missing value.");
+    }
+    return amount.value;
+}
+function readOptionalFiniteNumber(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return requireFiniteNumber(value, context);
+}
+function requireFiniteNumber(value, context) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`${context} must be a finite number.`);
+    }
+    return value;
+}
+function requireUnixSeconds(value, context) {
+    if (value === undefined || !Number.isFinite(value)) {
+        throw new Error(`${context} must be a finite Unix timestamp in seconds.`);
+    }
+    return value;
+}
+function unixSecondsToDateString(unixSeconds) {
+    return new Date(unixSeconds * 1000).toISOString().slice(0, 10);
+}
+//# sourceMappingURL=normalize.js.map

package/dist/packages/connectors/supabase/src/client.d.ts

@@ -0,0 +1,22 @@
+import type { SupabaseUsageHealthPayload } from "./normalize.js";
+export interface SupabaseManagementClient {
+    fetchUsageHealth(): Promise<SupabaseUsageHealthPayload>;
+}
+export type SupabaseManagementPath = "/v1/projects" | `/v1/projects/${string}/analytics/endpoints/usage.api-counts` | `/v1/projects/${string}/analytics/endpoints/usage.api-requests-count` | `/v1/projects/${string}/health`;
+export interface SupabaseManagementRequest {
+    path: SupabaseManagementPath;
+    query: Record<string, string | readonly string[]>;
+    headers: {
+        Authorization: string;
+    };
+}
+export interface SupabaseManagementTransport {
+    getJson(request: SupabaseManagementRequest): Promise<unknown>;
+}
+export interface CreateSupabaseManagementClientOptions {
+    accessToken: string;
+    transport?: SupabaseManagementTransport;
+}
+export declare function createSupabaseManagementClient(options: CreateSupabaseManagementClientOptions): SupabaseManagementClient;
+export declare function createStaticSupabaseUsageHealthClient(payload: SupabaseUsageHealthPayload): SupabaseManagementClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/packages/connectors/supabase/src/client.js

@@ -0,0 +1,132 @@
+const SUPABASE_API_BASE_URL = "https://api.supabase.com";
+const defaultSupabaseManagementTransport = {
+    async getJson(request) {
+        const url = new URL(request.path, SUPABASE_API_BASE_URL);
+        for (const [key, value] of Object.entries(request.query)) {
+            if (isReadonlyStringArray(value)) {
+                for (const nestedValue of value) {
+                    url.searchParams.append(key, nestedValue);
+                }
+                continue;
+            }
+            url.searchParams.set(key, value);
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: request.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Supabase Management API request failed with status ${response.status}.`);
+        }
+        return response.json();
+    },
+};
+export function createSupabaseManagementClient(options) {
+    const accessToken = options.accessToken.trim();
+    if (accessToken.length === 0) {
+        throw new Error("SUPABASE_ACCESS_TOKEN must not be blank.");
+    }
+    const transport = options.transport ?? defaultSupabaseManagementTransport;
+    return {
+        async fetchUsageHealth() {
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+            };
+            const projects = coerceProjectList(await transport.getJson({
+                path: "/v1/projects",
+                query: {},
+                headers,
+            }));
+            const usage = [];
+            const health = [];
+            const unavailable = [];
+            for (const project of projects) {
+                const ref = readProjectRef(project);
+                if (ref === undefined) {
+                    continue;
+                }
+                const encodedRef = encodeURIComponent(ref);
+                const usageEntry = {
+                    ref,
+                };
+                const apiCounts = await tryFetchSurface(transport, {
+                    path: `/v1/projects/${encodedRef}/analytics/endpoints/usage.api-counts`,
+                    query: {},
+                    headers,
+                }, unavailable, "usage.api-counts", ref);
+                if (apiCounts !== undefined) {
+                    usageEntry.apiCounts = apiCounts;
+                }
+                const apiRequestsCount = await tryFetchSurface(transport, {
+                    path: `/v1/projects/${encodedRef}/analytics/endpoints/usage.api-requests-count`,
+                    query: {},
+                    headers,
+                }, unavailable, "usage.api-requests-count", ref);
+                if (apiRequestsCount !== undefined) {
+                    usageEntry.apiRequestsCount = apiRequestsCount;
+                }
+                if (usageEntry.apiCounts !== undefined || usageEntry.apiRequestsCount !== undefined) {
+                    usage.push(usageEntry);
+                }
+                const healthPayload = await tryFetchSurface(transport, {
+                    path: `/v1/projects/${encodedRef}/health`,
+                    query: {},
+                    headers,
+                }, unavailable, "health", ref);
+                if (healthPayload !== undefined) {
+                    health.push({
+                        ref,
+                        ...healthPayload,
+                    });
+                }
+            }
+            return {
+                projects,
+                usage,
+                health,
+                unavailable,
+            };
+        },
+    };
+}
+export function createStaticSupabaseUsageHealthClient(payload) {
+    return {
+        async fetchUsageHealth() {
+            return payload;
+        },
+    };
+}
+async function tryFetchSurface(transport, request, unavailable, surface, ref) {
+    try {
+        return (await transport.getJson(request));
+    }
+    catch {
+        unavailable.push({
+            surface,
+            ref,
+        });
+        return undefined;
+    }
+}
+function coerceProjectList(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (isRecord(value) && Array.isArray(value.projects)) {
+        return value.projects;
+    }
+    return [];
+}
+function readProjectRef(project) {
+    return readOptionalNonBlankString(project.id) ?? readOptionalNonBlankString(project.ref);
+}
+function readOptionalNonBlankString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function isReadonlyStringArray(value) {
+    return Array.isArray(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=client.js.map

package/dist/packages/connectors/supabase/src/index.d.ts

@@ -0,0 +1,33 @@
+import { type SupabaseNormalizedSnapshotBundle } from "./normalize.js";
+export { createStaticSupabaseUsageHealthClient, createSupabaseManagementClient, type CreateSupabaseManagementClientOptions, type SupabaseManagementClient, type SupabaseManagementPath, type SupabaseManagementRequest, type SupabaseManagementTransport, } from "./client.js";
+export { normalizeSupabaseUsageHealth, redactedSupabaseProjectRef, type NormalizeSupabaseUsageHealthInput, type SupabaseApiCountsResponse, type SupabaseApiCountsRow, type SupabaseApiRequestsCountResponse, type SupabaseApiRequestsCountRow, type SupabaseBillingSnapshot, type SupabaseCostEstimate, type SupabaseNormalizedSnapshotBundle, type SupabaseProject, type SupabaseProjectHealth, type SupabaseProjectHealthService, type SupabaseProjectUsage, type SupabaseServiceHealthSnapshot, type SupabaseUnavailableSurface, type SupabaseUsageHealthPayload, type SupabaseUsageSnapshot, } from "./normalize.js";
+import type { SupabaseManagementClient } from "./client.js";
+export interface SupabaseProviderCollectionContext {
+    now(): Date;
+}
+export interface SupabaseProviderConnector {
+    kind: "supabase";
+    displayName: "Supabase Usage/Health";
+    access: "read-only";
+    collect(context: SupabaseProviderCollectionContext): Promise<SupabaseProviderCollectionResult>;
+}
+export interface SupabaseProviderCollectionResult {
+    collectedAt: string;
+    status: "ok" | "partial" | "error";
+    snapshots: SupabaseNormalizedSnapshotBundle;
+    alerts: readonly SupabaseProviderAlert[];
+    errors?: readonly string[];
+}
+export interface SupabaseProviderAlert {
+    provider: "supabase";
+    createdAt: string;
+    severity: "warning";
+    category: "provider-sync";
+    title: "Supabase usage/health sync failed" | "Supabase projects surface unavailable" | "Supabase usage.api-counts surface unavailable" | "Supabase usage.api-requests-count surface unavailable" | "Supabase health surface unavailable";
+    message: "Supabase usage/health request failed before normalized snapshots were collected." | "Supabase projects request failed before normalized snapshots were collected." | "Supabase usage.api-counts request failed before normalized snapshots were collected." | "Supabase usage.api-requests-count request failed before normalized snapshots were collected." | "Supabase health request failed before normalized snapshots were collected.";
+}
+export interface SupabaseUsageHealthConnectorOptions {
+    client: SupabaseManagementClient;
+}
+export declare function createSupabaseUsageHealthConnector(options: SupabaseUsageHealthConnectorOptions): SupabaseProviderConnector;
+//# sourceMappingURL=index.d.ts.map