@moneysiren/cli 0.1.0-alpha.0

package/dist/apps/cli/src/commands/report.js

@@ -0,0 +1,206 @@
+import { initializeLocalStore, readLocalStore, recordLocalReportRun, } from "../../../../packages/db/src/index.js";
+import { renderDailyReport, sendSlackReport, } from "../../../../packages/report/src/index.js";
+import { loadCliConfig, resolveDbPath } from "./shared.js";
+const DAILY_REPORT_TIME_ZONE_ENV_KEY = "MONEYSIREN_REPORT_TIME_ZONE";
+const DEFAULT_DAILY_REPORT_TIME_ZONE = "Asia/Seoul";
+export async function runReportCommand(args, context) {
+    const parsedArgs = parseDailyReportArgs(args);
+    if (parsedArgs === undefined) {
+        context.stderr("Usage: moneysiren report daily --lang ko [--send slack]");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    await initializeLocalStore({ dbPath });
+    const now = context.now();
+    const generatedAt = now.toISOString();
+    const reportDate = formatDailyReportDate(now, resolveDailyReportTimeZone(context.env));
+    const store = await readLocalStore({ dbPath });
+    const reportInput = {
+        reportDate,
+        generatedAt,
+        providerSummaries: buildProviderSummaries(store),
+        reportRunStatus: parsedArgs.deliveryTarget === "slack" ? "sent" : "rendered",
+    };
+    if (parsedArgs.deliveryTarget === "slack") {
+        return sendDailyReportToSlack({
+            context,
+            dbPath,
+            reportDate,
+            generatedAt,
+            reportInput,
+            webhookEnvKey: config.slack.requiredEnvKey,
+        });
+    }
+    await recordLocalReportRun({
+        dbPath,
+        createdAt: generatedAt,
+        reportDate,
+        language: "ko",
+        deliveryTarget: "stdout",
+        status: "rendered",
+    });
+    context.stdout(renderDailyReport(reportInput, { lang: "ko" }));
+    context.stdout("Report run recorded: stdout");
+    return 0;
+}
+function parseDailyReportArgs(args) {
+    const [reportKind, ...rest] = args;
+    if (reportKind !== "daily") {
+        return undefined;
+    }
+    let lang;
+    let deliveryTarget = "stdout";
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        if (arg === "--lang") {
+            const value = rest[index + 1];
+            if (value === undefined) {
+                return undefined;
+            }
+            lang = value;
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--lang=")) {
+            lang = arg.slice("--lang=".length);
+            continue;
+        }
+        if (arg === "--send") {
+            const value = rest[index + 1];
+            if (value !== "slack") {
+                return undefined;
+            }
+            deliveryTarget = "slack";
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--send=")) {
+            const value = arg.slice("--send=".length);
+            if (value !== "slack") {
+                return undefined;
+            }
+            deliveryTarget = "slack";
+            continue;
+        }
+        return undefined;
+    }
+    if (lang !== "ko") {
+        return undefined;
+    }
+    return {
+        deliveryTarget,
+    };
+}
+function resolveDailyReportTimeZone(env) {
+    const configuredTimeZone = env[DAILY_REPORT_TIME_ZONE_ENV_KEY]?.trim();
+    return configuredTimeZone === undefined || configuredTimeZone.length === 0
+        ? DEFAULT_DAILY_REPORT_TIME_ZONE
+        : configuredTimeZone;
+}
+function formatDailyReportDate(date, timeZone) {
+    let parts;
+    try {
+        parts = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).formatToParts(date);
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            throw new Error(`${DAILY_REPORT_TIME_ZONE_ENV_KEY} must be a valid IANA time zone.`);
+        }
+        throw error;
+    }
+    const year = parts.find((part) => part.type === "year")?.value;
+    const month = parts.find((part) => part.type === "month")?.value;
+    const day = parts.find((part) => part.type === "day")?.value;
+    if (year === undefined || month === undefined || day === undefined) {
+        throw new Error(`Could not format daily report date for ${timeZone}.`);
+    }
+    return `${year}-${month}-${day}`;
+}
+async function sendDailyReportToSlack(input) {
+    const webhookUrl = input.context.env[input.webhookEnvKey]?.trim();
+    if (webhookUrl === undefined || webhookUrl.length === 0) {
+        await recordSlackReportRun(input, "error");
+        input.context.stderr(`${input.webhookEnvKey} is required for Slack delivery.`);
+        return 1;
+    }
+    const text = renderDailyReport(input.reportInput, { lang: "ko" });
+    try {
+        const options = input.context.slackTransport === undefined
+            ? {
+                webhookUrl,
+                text,
+            }
+            : {
+                webhookUrl,
+                text,
+                transport: input.context.slackTransport,
+            };
+        await sendSlackReport(options);
+        await recordSlackReportRun(input, "sent");
+        input.context.stdout("Slack report sent: slack");
+        return 0;
+    }
+    catch (error) {
+        await recordSlackReportRun(input, "error");
+        input.context.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+async function recordSlackReportRun(input, status) {
+    await recordLocalReportRun({
+        dbPath: input.dbPath,
+        createdAt: input.generatedAt,
+        reportDate: input.reportDate,
+        language: "ko",
+        deliveryTarget: "slack",
+        status,
+    });
+}
+function buildProviderSummaries(store) {
+    return 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 serviceHealthSnapshots = 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 currency = costEstimates[0]?.currency ?? billingSnapshots[0]?.currency ?? "USD";
+        return {
+            provider: provider.key,
+            displayName: provider.displayName,
+            syncStatus: summarizeSyncStatus([
+                usageSnapshots.length,
+                billingSnapshots.length,
+                serviceHealthSnapshots.length,
+                costEstimates.length,
+            ]),
+            usageSnapshotCount: usageSnapshots.length,
+            billingSnapshotCount: billingSnapshots.length,
+            healthStatus: summarizeHealth(serviceHealthSnapshots.map((snapshot) => snapshot.status)),
+            estimatedAmountMinor: costEstimates.reduce((total, snapshot) => total + snapshot.estimatedAmountMinor, 0),
+            currency,
+            alertCount: alerts.length,
+        };
+    });
+}
+function summarizeSyncStatus(snapshotCounts) {
+    return snapshotCounts.some((count) => count > 0) ? "ok" : "error";
+}
+function summarizeHealth(statuses) {
+    if (statuses.includes("down")) {
+        return "down";
+    }
+    if (statuses.includes("degraded")) {
+        return "degraded";
+    }
+    if (statuses.includes("unknown") || statuses.length === 0) {
+        return "unknown";
+    }
+    return "ok";
+}
+//# sourceMappingURL=report.js.map

package/dist/apps/cli/src/commands/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runServeCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runOpenCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runDesktopCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/apps/cli/src/commands/runtime.js

@@ -0,0 +1,133 @@
+import { createFallbackLocalRuntimeAdapter, } from "../runtime-adapter.js";
+const SERVE_USAGE = "Usage: moneysiren serve [--port <port>]";
+const OPEN_USAGE = "Usage: moneysiren open";
+const DESKTOP_USAGE = "Usage: moneysiren desktop status";
+export async function runServeCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(SERVE_USAGE);
+        return 0;
+    }
+    const parsed = parseServeArgs(args);
+    if (parsed === undefined) {
+        context.stderr(SERVE_USAGE);
+        return 1;
+    }
+    const result = await runtimeAdapter(context).startRuntime({
+        headless: false,
+        ...(parsed.port === undefined ? {} : { port: parsed.port }),
+    });
+    return writeStartRuntimeResult(context, result, "MoneySiren local runtime");
+}
+export async function runOpenCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(OPEN_USAGE);
+        return 0;
+    }
+    if (args.length > 0) {
+        context.stderr(OPEN_USAGE);
+        return 1;
+    }
+    const adapter = runtimeAdapter(context);
+    const runtime = await findHealthyRuntime(adapter);
+    const startResult = runtime === null
+        ? await adapter.startRuntime({
+            headless: true,
+        })
+        : {
+            status: "running",
+            runtime,
+        };
+    if (startResult.status === "unavailable") {
+        return writeStartRuntimeResult(context, startResult, "MoneySiren open");
+    }
+    context.stdout("MoneySiren local API runtime ready");
+    context.stdout(`Runtime: ${startResult.status}`);
+    context.stdout(`Local API URL: ${startResult.runtime.baseUrl}`);
+    context.stdout("Dashboard UI: not opened because this runtime URL is a JSON API.");
+    context.stdout("Start the web dashboard:");
+    context.stdout("  pnpm --filter @moneysiren/web dev");
+    context.stdout("Then open: http://localhost:3000");
+    return 0;
+}
+export async function runDesktopCommand(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        context.stdout(DESKTOP_USAGE);
+        return 0;
+    }
+    if (subcommand !== "status" || rest.length > 0) {
+        context.stderr(DESKTOP_USAGE);
+        return 1;
+    }
+    const adapter = runtimeAdapter(context);
+    const runtime = await adapter.findRuntime();
+    context.stdout("MoneySiren desktop status");
+    if (runtime === null) {
+        context.stdout("Runtime: not running");
+        context.stdout("Runtime lock: not found");
+        context.stdout("Desktop shell: not detected by CLI");
+        context.stdout("Next step: run `moneysiren serve` or start the native tray app.");
+        return 0;
+    }
+    const healthy = await adapter.assertRuntimeHealthy(runtime);
+    context.stdout(`Runtime: ${healthy ? "healthy" : "unhealthy"}`);
+    context.stdout(`Base URL: ${runtime.baseUrl}`);
+    context.stdout(`PID: ${runtime.pid}`);
+    context.stdout(`Started at: ${runtime.startedAt}`);
+    context.stdout(`Version: ${runtime.version}`);
+    context.stdout("Desktop shell: not detected by CLI");
+    return healthy ? 0 : 1;
+}
+function runtimeAdapter(context) {
+    return context.localRuntime ?? createFallbackLocalRuntimeAdapter(context);
+}
+async function findHealthyRuntime(adapter) {
+    const runtime = await adapter.findRuntime();
+    if (runtime === null) {
+        return null;
+    }
+    return await adapter.assertRuntimeHealthy(runtime) ? runtime : null;
+}
+function writeStartRuntimeResult(context, result, heading) {
+    if (result.status !== "unavailable") {
+        context.stdout(heading);
+        context.stdout(`Runtime: ${result.status}`);
+        context.stdout(`Base URL: ${result.runtime.baseUrl}`);
+        context.stdout(`PID: ${result.runtime.pid}`);
+        return 0;
+    }
+    context.stderr(`${heading}: unavailable`);
+    context.stderr(result.reason);
+    for (const line of result.guidance) {
+        context.stderr(line);
+    }
+    return 1;
+}
+function parseServeArgs(args) {
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--port") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return undefined;
+            }
+            port = parsePort(value);
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--port=")) {
+            port = parsePort(arg.slice("--port=".length));
+            continue;
+        }
+        return undefined;
+    }
+    if (port === undefined) {
+        return {};
+    }
+    return Number.isSafeInteger(port) && port > 0 && port <= 65_535 ? { port } : undefined;
+}
+function parsePort(value) {
+    return Number.parseInt(value, 10);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/apps/cli/src/commands/shared.d.ts

@@ -0,0 +1,9 @@
+import { type MoneySirenConfig } from "../../../../packages/config/src/index.js";
+export interface ParsedFlagResult {
+    value?: string;
+    remainingArgs: string[];
+}
+export declare function loadCliConfig(env: Record<string, string | undefined>): MoneySirenConfig;
+export declare function resolveDbPath(cwd: string, configuredDbPath: string): string;
+export declare function readFlag(args: readonly string[], flagName: string): ParsedFlagResult;
+//# sourceMappingURL=shared.d.ts.map

package/dist/apps/cli/src/commands/shared.js

@@ -0,0 +1,29 @@
+import { isAbsolute, join } from "node:path";
+import { loadMoneySirenConfig } from "../../../../packages/config/src/index.js";
+export function loadCliConfig(env) {
+    return loadMoneySirenConfig(env);
+}
+export function resolveDbPath(cwd, configuredDbPath) {
+    return isAbsolute(configuredDbPath) ? configuredDbPath : join(cwd, configuredDbPath);
+}
+export function readFlag(args, flagName) {
+    const remainingArgs = [];
+    let value;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === flagName) {
+            value = args[index + 1];
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith(`${flagName}=`)) {
+            value = arg.slice(flagName.length + 1);
+            continue;
+        }
+        if (arg !== undefined) {
+            remainingArgs.push(arg);
+        }
+    }
+    return value === undefined ? { remainingArgs } : { value, remainingArgs };
+}
+//# sourceMappingURL=shared.js.map

package/dist/apps/cli/src/commands/summary.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runSummaryCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=summary.d.ts.map

package/dist/apps/cli/src/commands/summary.js

@@ -0,0 +1,15 @@
+import { readSanitizedSummary } from "../summary-model.js";
+const SUMMARY_USAGE = "Usage: moneysiren summary --json";
+export async function runSummaryCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(SUMMARY_USAGE);
+        return 0;
+    }
+    if (args.length !== 1 || args[0] !== "--json") {
+        context.stderr(SUMMARY_USAGE);
+        return 1;
+    }
+    context.stdout(JSON.stringify(await readSanitizedSummary(context), null, 2));
+    return 0;
+}
+//# sourceMappingURL=summary.js.map

package/dist/apps/cli/src/commands/sync.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runSyncCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=sync.d.ts.map