@moneysiren/app 0.1.0-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MoneySiren contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# MoneySiren App
+
+One-command alpha installer for MoneySiren.
+
+This package bundles the MoneySiren CLI entrypoints and, on global npm installs, runs `msiren install --all` to download the local web dashboard runtime and HUD desktop artifacts from the matching GitHub Release.
+
+## Install
+
+```bash
+npm install -g @moneysiren/app@alpha
+msiren start
+msiren hud
+```
+
+The package installs both commands:
+
+- `moneysiren`
+- `msiren`
+
+## What It Installs
+
+- CLI command surface.
+- Local web dashboard runtime.
+- HUD desktop artifact.
+
+The Web/HUD artifacts are verified against published SHA256 checksums. Alpha Windows HUD artifacts may be unsigned until release signing is fully configured.
+
+## Opt Out
+
+To install only the package command and skip Web/HUD asset download:
+
+```bash
+MONEYSIREN_SKIP_APP_POSTINSTALL=1 npm install -g @moneysiren/app@alpha
+msiren install --all
+```
+
+For local non-global package review, postinstall does not download release assets automatically. Run `msiren install --all` explicitly when needed.
+
+## Stable Channel
+
+During alpha, install with `@alpha`. Stable releases will use:
+
+```bash
+npm install -g @moneysiren/app
+```

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

@@ -0,0 +1,59 @@
+import { type CliLocalRuntimeAdapter } from "./runtime-adapter.js";
+import type { CliDesktopRuntimeAdapter } from "./desktop-runtime.js";
+import { type Theme } from "./theme.js";
+import type { SlackReportTransport } from "../../../packages/report/src/index.js";
+import type { AwsCostExplorerClientAdapter } from "../../../packages/connectors/aws/src/index.js";
+import type { CloudflareBillingUsageClient } from "../../../packages/connectors/cloudflare/src/index.js";
+import type { OpenAiUsageCostsClient } from "../../../packages/connectors/openai/src/index.js";
+import type { SupabaseManagementClient } from "../../../packages/connectors/supabase/src/index.js";
+export { CLI_VERSION } from "./version.js";
+export interface CliRuntime {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    now?: () => Date;
+    stdin?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    stdinIsTTY?: boolean;
+    stdoutIsTTY?: boolean;
+    interactive?: boolean;
+    stdout?: (line: string) => void;
+    stderr?: (line: string) => void;
+    stdoutBuffer?: string[];
+    stderrBuffer?: string[];
+    slackTransport?: SlackReportTransport;
+    liveClients?: CliLiveClients;
+    fetch?: typeof fetch;
+    localRuntime?: CliLocalRuntimeAdapter;
+    desktopRuntime?: CliDesktopRuntimeAdapter;
+    openUrl?: (url: string) => Promise<void> | void;
+}
+export interface CliLiveClients {
+    awsCostExplorer?: AwsCostExplorerClientAdapter;
+    cloudflareBillingUsage?: CloudflareBillingUsageClient;
+    openaiUsageCosts?: OpenAiUsageCostsClient;
+    supabaseUsageHealth?: SupabaseManagementClient;
+}
+export interface CliExecutionContext {
+    cwd: string;
+    env: Record<string, string | undefined>;
+    now: () => Date;
+    stdout(line: string): void;
+    stderr(line: string): void;
+    slackTransport?: SlackReportTransport;
+    liveClients?: CliLiveClients;
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    openUrl(url: string): Promise<void> | void;
+    stdin?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    interactive: boolean;
+    theme: Theme;
+    localRuntime?: CliLocalRuntimeAdapter;
+    desktopRuntime?: CliDesktopRuntimeAdapter;
+}
+export interface CliResult {
+    exitCode: number;
+    stdout: readonly string[];
+    stderr: readonly string[];
+}
+export declare function runCli(args: readonly string[], runtime?: CliRuntime): Promise<CliResult>;
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1,199 @@
+import { runDashboardCommand } from "./commands/dashboard.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { runInitCommand } from "./commands/init.js";
+import { runInstallCommand } from "./commands/install.js";
+import { runModesCommand } from "./commands/modes.js";
+import { runNotifyCommand } from "./commands/notify.js";
+import { runReportCommand } from "./commands/report.js";
+import { runDesktopCommand, runHudCommand, runOpenCommand, runRestartCommand, runServeCommand, runStartCommand, runStatusCommand, runStopCommand, } from "./commands/runtime.js";
+import { runSummaryCommand } from "./commands/summary.js";
+import { runSyncCommand } from "./commands/sync.js";
+import { runThemeCommand } from "./commands/theme.js";
+import { renderHelpScreen, renderHomeScreen } from "./home.js";
+import { runSlashPrompt } from "./interactive.js";
+import { openUrlInBrowser } from "./runtime-adapter.js";
+import { resolveSlashCommand } from "./slash.js";
+import { createTheme } from "./theme.js";
+import { CLI_VERSION } from "./version.js";
+export { CLI_VERSION } from "./version.js";
+const HELP = renderHelpScreen(CLI_VERSION);
+export async function runCli(args, runtime = {}) {
+    const stdout = runtime.stdoutBuffer ?? [];
+    const stderr = runtime.stderrBuffer ?? [];
+    const env = runtime.env ?? process.env;
+    const stdinIsTTY = runtime.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+    const stdoutIsTTY = runtime.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+    const theme = createTheme({
+        cwd: runtime.cwd ?? process.cwd(),
+        env,
+        stdoutIsTTY,
+    });
+    const context = {
+        cwd: runtime.cwd ?? process.cwd(),
+        env,
+        now: runtime.now ?? (() => new Date()),
+        stdout(line) {
+            if (runtime.stdoutBuffer === undefined && runtime.stdout !== undefined) {
+                stdout.push(line);
+            }
+            if (runtime.stdout === undefined) {
+                stdout.push(line);
+                return;
+            }
+            runtime.stdout(line);
+        },
+        stderr(line) {
+            if (runtime.stderrBuffer === undefined && runtime.stderr !== undefined) {
+                stderr.push(line);
+            }
+            if (runtime.stderr === undefined) {
+                stderr.push(line);
+                return;
+            }
+            runtime.stderr(line);
+        },
+        fetch: runtime.fetch ?? globalThis.fetch,
+        openUrl: runtime.openUrl ?? openUrlInBrowser,
+        interactive: runtime.interactive ?? shouldEnterInteractivePrompt({
+            env,
+            stdinIsTTY,
+            stdoutIsTTY,
+        }),
+        theme,
+        ...(runtime.localRuntime === undefined ? {} : { localRuntime: runtime.localRuntime }),
+        ...(runtime.desktopRuntime === undefined ? {} : { desktopRuntime: runtime.desktopRuntime }),
+    };
+    context.stdin = runtime.stdin ?? process.stdin;
+    context.output = runtime.output ?? process.stdout;
+    if (runtime.slackTransport !== undefined) {
+        context.slackTransport = runtime.slackTransport;
+    }
+    if (runtime.liveClients !== undefined) {
+        context.liveClients = runtime.liveClients;
+    }
+    try {
+        return {
+            exitCode: await dispatchCommand(stripLeadingArgumentSeparator(args), context),
+            stdout,
+            stderr,
+        };
+    }
+    catch (error) {
+        context.stderr(error instanceof Error ? error.message : String(error));
+        return {
+            exitCode: 1,
+            stdout,
+            stderr,
+        };
+    }
+}
+function stripLeadingArgumentSeparator(args) {
+    return args[0] === "--" ? args.slice(1) : args;
+}
+async function dispatchCommand(args, context) {
+    const [command, ...rest] = args;
+    if (command === undefined) {
+        context.stdout(renderHomeScreen({
+            version: CLI_VERSION,
+            theme: context.theme,
+        }));
+        if (context.interactive) {
+            return runSlashPrompt(context, (promptArgs) => dispatchCommand(promptArgs, context));
+        }
+        return 0;
+    }
+    if (command.startsWith("/")) {
+        return dispatchSlashCommand(args, context);
+    }
+    if (command === "--help" || command === "-h" || command === "help") {
+        context.stdout(HELP);
+        return 0;
+    }
+    if (command === "--version" || command === "-v" || command === "version") {
+        context.stdout(CLI_VERSION);
+        return 0;
+    }
+    if (command === "init") {
+        return runInitCommand(rest, context);
+    }
+    if (command === "install") {
+        return runInstallCommand(rest, context);
+    }
+    if (command === "doctor") {
+        return runDoctorCommand(rest, context);
+    }
+    if (command === "modes") {
+        return runModesCommand(rest, context);
+    }
+    if (command === "dashboard") {
+        return runDashboardCommand(rest, context);
+    }
+    if (command === "serve") {
+        return runServeCommand(rest, context);
+    }
+    if (command === "start") {
+        return runStartCommand(rest, context);
+    }
+    if (command === "status") {
+        return runStatusCommand(rest, context);
+    }
+    if (command === "stop") {
+        return runStopCommand(rest, context);
+    }
+    if (command === "restart") {
+        return runRestartCommand(rest, context);
+    }
+    if (command === "hud") {
+        return runHudCommand(rest, context);
+    }
+    if (command === "open") {
+        return runOpenCommand(rest, context);
+    }
+    if (command === "sync") {
+        return runSyncCommand(rest, context);
+    }
+    if (command === "summary") {
+        return runSummaryCommand(rest, context);
+    }
+    if (command === "notify") {
+        return runNotifyCommand(rest, context);
+    }
+    if (command === "desktop") {
+        return runDesktopCommand(rest, context);
+    }
+    if (command === "report") {
+        return runReportCommand(rest, context);
+    }
+    if (command === "theme") {
+        return runThemeCommand(rest, context);
+    }
+    context.stderr(`Unknown command: ${command}`);
+    context.stderr("Run `msiren --help` or `moneysiren --help` for usage.");
+    return 1;
+}
+async function dispatchSlashCommand(args, context) {
+    const resolved = resolveSlashCommand(args);
+    if (resolved.kind === "dispatch") {
+        return dispatchCommand(resolved.args, context);
+    }
+    if (resolved.kind === "quit") {
+        context.stdout("Bye.");
+        return 0;
+    }
+    context.stderr(resolved.message);
+    if (resolved.usage !== undefined) {
+        context.stderr(resolved.usage);
+    }
+    return 1;
+}
+function shouldEnterInteractivePrompt(input) {
+    return input.stdinIsTTY && input.stdoutIsTTY && !isTruthyEnvValue(input.env.CI);
+}
+function isTruthyEnvValue(value) {
+    if (value === undefined) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 && normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+//# sourceMappingURL=cli.js.map

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

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

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

@@ -0,0 +1,239 @@
+import { stat } from "node:fs/promises";
+import { loadCliConfig, resolveDbPath } from "./shared.js";
+const DEFAULT_DASHBOARD_URL = "http://localhost:3000";
+const DASHBOARD_CHECK_TIMEOUT_MS = 2_000;
+const DASHBOARD_CHECK_USAGE = "Usage: moneysiren dashboard check [--url <local-dashboard-url>]";
+class DashboardCheckTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`Dashboard API request timed out after ${timeoutMs}ms.`);
+    }
+}
+export async function runDashboardCommand(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        context.stdout(DASHBOARD_CHECK_USAGE);
+        return 0;
+    }
+    if (subcommand !== "check") {
+        context.stderr(DASHBOARD_CHECK_USAGE);
+        return 1;
+    }
+    if (rest.includes("--help") || rest.includes("-h")) {
+        context.stdout(DASHBOARD_CHECK_USAGE);
+        return 0;
+    }
+    const parsedArgs = parseDashboardCheckArgs(rest);
+    if (parsedArgs === undefined) {
+        context.stderr(DASHBOARD_CHECK_USAGE);
+        return 1;
+    }
+    const sanitizedUrl = sanitizeDashboardUrl(parsedArgs.dashboardUrl);
+    if (sanitizedUrl instanceof Error) {
+        context.stderr(sanitizedUrl.message);
+        context.stderr(DASHBOARD_CHECK_USAGE);
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    const dbExists = await pathExists(dbPath);
+    context.stdout("MoneySiren dashboard check");
+    context.stdout(`Dashboard URL: ${sanitizedUrl.dashboardUrl}`);
+    context.stdout(`API endpoint: ${sanitizedUrl.apiUrl}`);
+    if (sanitizedUrl.ignoredUnsafeParts) {
+        context.stdout("URL note: path, query, and hash were ignored for safety.");
+    }
+    context.stdout(`DB path: ${config.dbPath}`);
+    context.stdout(`DB exists locally: ${dbExists}`);
+    try {
+        const response = await fetchDashboardApi(context, sanitizedUrl.apiUrl, DASHBOARD_CHECK_TIMEOUT_MS);
+        context.stdout(`API status: ${response.status}${response.ok ? " OK" : ""}`);
+        if (!response.ok) {
+            writeDashboardDevGuidance(context);
+            return 1;
+        }
+        const payload = parseDashboardPayload(await response.json());
+        if (payload === undefined) {
+            context.stderr("Dashboard API returned an unexpected payload shape.");
+            writeDashboardDevGuidance(context);
+            return 1;
+        }
+        const dashboardState = isSafeEmptyDashboardState(payload) ? "safe empty state" : "data available";
+        context.stdout(`Payload source: ${payload.source}`);
+        context.stdout(`Provider count: ${payload.providerCount}`);
+        context.stdout(`Generated at: ${payload.generatedAt}`);
+        context.stdout(`Payload database: ${payload.databaseAvailable ? "available" : "missing"} (${payload.databaseReason})`);
+        context.stdout(`Dashboard state: ${dashboardState}`);
+        writeDashboardSuccessGuidance(context, payload);
+        return 0;
+    }
+    catch (error) {
+        context.stdout(error instanceof DashboardCheckTimeoutError
+            ? `API status: timeout after ${DASHBOARD_CHECK_TIMEOUT_MS}ms`
+            : "API status: unreachable");
+        writeDashboardDevGuidance(context);
+        return 1;
+    }
+}
+function parseDashboardCheckArgs(args) {
+    let dashboardUrl = DEFAULT_DASHBOARD_URL;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--url") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return undefined;
+            }
+            dashboardUrl = value;
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--url=")) {
+            const value = arg.slice("--url=".length);
+            if (value.trim().length === 0) {
+                return undefined;
+            }
+            dashboardUrl = value;
+            continue;
+        }
+        return undefined;
+    }
+    return {
+        dashboardUrl,
+    };
+}
+function sanitizeDashboardUrl(rawUrl) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(rawUrl.trim());
+    }
+    catch {
+        return new Error("Dashboard URL must be a valid http:// or https:// URL.");
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        return new Error("Dashboard URL must use http:// or https://.");
+    }
+    if (parsedUrl.username.length > 0 || parsedUrl.password.length > 0) {
+        return new Error("Dashboard URL must not include credentials.");
+    }
+    if (!isLocalDashboardHost(parsedUrl.hostname)) {
+        return new Error("Dashboard URL must point to localhost, 127.0.0.1, ::1, or 0.0.0.0.");
+    }
+    const dashboardUrl = parsedUrl.origin;
+    const apiUrl = new URL("/api/dashboard", dashboardUrl).toString();
+    const ignoredUnsafeParts = parsedUrl.pathname !== "/" || parsedUrl.search.length > 0 || parsedUrl.hash.length > 0;
+    return {
+        dashboardUrl,
+        apiUrl,
+        ignoredUnsafeParts,
+    };
+}
+function isLocalDashboardHost(hostname) {
+    return hostname === "localhost" ||
+        hostname === "127.0.0.1" ||
+        hostname === "0.0.0.0" ||
+        hostname === "::1" ||
+        hostname === "[::1]";
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return "yes";
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return "no";
+        }
+        return "unknown";
+    }
+}
+async function fetchDashboardApi(context, apiUrl, timeoutMs) {
+    const controller = new AbortController();
+    let timeout;
+    const fetchPromise = context.fetch(apiUrl, {
+        method: "GET",
+        headers: {
+            Accept: "application/json",
+        },
+        signal: controller.signal,
+    });
+    fetchPromise.catch(() => undefined);
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            controller.abort();
+            reject(new DashboardCheckTimeoutError(timeoutMs));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([fetchPromise, timeoutPromise]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+        }
+    }
+}
+function parseDashboardPayload(payload) {
+    if (!isRecord(payload)) {
+        return undefined;
+    }
+    const source = payload.source;
+    const generatedAt = payload.generatedAt;
+    const database = payload.database;
+    const summary = payload.summary;
+    if ((source !== "sqlite" && source !== "empty") || !isSafeIsoTimestamp(generatedAt)) {
+        return undefined;
+    }
+    if (!isRecord(database) || !isRecord(summary)) {
+        return undefined;
+    }
+    const databaseAvailable = database.available;
+    const databaseReason = database.reason;
+    const providerCount = summary.providerCount;
+    if (typeof databaseAvailable !== "boolean" ||
+        (databaseReason !== "ok" && databaseReason !== "missing") ||
+        typeof providerCount !== "number" ||
+        !Number.isSafeInteger(providerCount) ||
+        providerCount < 0) {
+        return undefined;
+    }
+    return {
+        source,
+        generatedAt,
+        providerCount,
+        databaseAvailable,
+        databaseReason,
+    };
+}
+function isSafeEmptyDashboardState(payload) {
+    return payload.source === "empty" &&
+        payload.providerCount === 0 &&
+        !payload.databaseAvailable &&
+        payload.databaseReason === "missing";
+}
+function isSafeIsoTimestamp(value) {
+    return typeof value === "string" &&
+        value.length <= 40 &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value) &&
+        !Number.isNaN(Date.parse(value));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function writeDashboardDevGuidance(context) {
+    context.stderr("Next step: start the local dashboard from the repo root:");
+    context.stderr("  pnpm --filter @moneysiren/web dev");
+    context.stderr("Then re-run:");
+    context.stderr("  pnpm --filter moneysiren dev -- dashboard check");
+}
+function writeDashboardSuccessGuidance(context, payload) {
+    if (isSafeEmptyDashboardState(payload)) {
+        context.stdout("Next step: sync mock data if you want a populated dashboard review:");
+        context.stdout("  pnpm --filter moneysiren dev -- sync --provider mock");
+        return;
+    }
+    context.stdout("Next step: open the dashboard URL above in your browser.");
+}
+//# sourceMappingURL=dashboard.js.map

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

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

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

@@ -0,0 +1,25 @@
+import { loadCliConfig } from "./shared.js";
+const PROVIDER_ORDER = ["aws", "openai", "supabase", "cloudflare"];
+export async function runDoctorCommand(args, context) {
+    if (args.length > 0) {
+        context.stderr("Usage: moneysiren doctor");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    context.stdout("MoneySiren doctor");
+    context.stdout(`DB path: ${config.dbPath}`);
+    context.stdout(`telemetry: ${config.telemetryEnabled ? "enabled" : "disabled"}`);
+    context.stdout("mock provider: available");
+    for (const provider of PROVIDER_ORDER) {
+        context.stdout(`${provider}: ${formatProviderReadiness(config.providers[provider])}`);
+    }
+    context.stdout(`slack: ${config.slack.webhookConfigured ? "configured" : "not configured"}`);
+    return 0;
+}
+function formatProviderReadiness(providerConfig) {
+    if (providerConfig.configured) {
+        return "configured";
+    }
+    return `missing ${providerConfig.missingEnvKeys.join(", ")}`;
+}
+//# sourceMappingURL=doctor.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { initializeLocalStore } from "../../../../packages/db/src/index.js";
+import { loadCliConfig, resolveDbPath } from "./shared.js";
+export async function runInitCommand(args, context) {
+    if (args.length > 0) {
+        context.stderr("Usage: moneysiren init");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    const result = await initializeLocalStore({ dbPath });
+    const migrationSummary = result.appliedMigrationIds.length > 0
+        ? `applied migrations: ${result.appliedMigrationIds.join(", ")}`
+        : `migrations already applied: ${result.skippedMigrationIds.join(", ")}`;
+    context.stdout(`Initialized MoneySiren local storage at ${config.dbPath}`);
+    context.stdout(migrationSummary);
+    return 0;
+}
+//# sourceMappingURL=init.js.map

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

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