@moneysiren/cli 0.1.0-alpha.0

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+const result = await runCli(process.argv.slice(2), {
+    cwd: process.cwd(),
+    env: process.env,
+    stdin: process.stdin,
+    output: process.stdout,
+    stdinIsTTY: process.stdin.isTTY,
+    stdoutIsTTY: process.stdout.isTTY,
+    stdout: (line) => console.log(line),
+    stderr: (line) => console.error(line),
+});
+process.exitCode = result.exitCode;
+//# sourceMappingURL=index.js.map

package/dist/apps/cli/src/install-profile.d.ts

@@ -0,0 +1,35 @@
+export declare const INSTALL_SURFACES: readonly ["cli", "web", "hud"];
+export declare const DEFAULT_INSTALL_SURFACES: readonly InstallSurface[];
+export type InstallSurface = (typeof INSTALL_SURFACES)[number];
+export type InstallProfileSource = "cli" | "postinstall";
+export interface InstallProfile {
+    version: 1;
+    selectedSurfaces: readonly InstallSurface[];
+    recommendedDefault: boolean;
+    localOnly: true;
+    secretsReturned: false;
+    source: InstallProfileSource;
+    installedAt: string;
+    updatedAt: string;
+}
+export interface InstallProfileFileOptions {
+    env?: Record<string, string | undefined>;
+    now?: () => Date;
+    path?: string;
+    platform?: NodeJS.Platform;
+}
+export declare function resolveInstallProfilePath(options?: InstallProfileFileOptions): string;
+export declare function readInstallProfileFile(options?: InstallProfileFileOptions): Promise<InstallProfile | null>;
+export declare function writeInstallProfileFile(input: {
+    selectedSurfaces: readonly InstallSurface[];
+    source: InstallProfileSource;
+    recommendedDefault?: boolean;
+}, options?: InstallProfileFileOptions): Promise<InstallProfile>;
+export declare function parseInstallProfile(value: unknown): InstallProfile | null;
+export declare function parseInstallSurfaces(value: unknown): readonly InstallSurface[];
+export declare function normalizeInstallSurfaces(values: readonly InstallSurface[]): readonly InstallSurface[];
+export declare function isRecommendedInstallSelection(values: readonly InstallSurface[]): boolean;
+export declare function formatInstallSurfaces(values: readonly InstallSurface[]): string;
+export declare function installSurfaceLabel(surface: InstallSurface): string;
+export declare function isInstallSurface(value: unknown): value is InstallSurface;
+//# sourceMappingURL=install-profile.d.ts.map

package/dist/apps/cli/src/install-profile.js

@@ -0,0 +1,124 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, posix, win32 } from "node:path";
+export const INSTALL_SURFACES = ["cli", "web", "hud"];
+export const DEFAULT_INSTALL_SURFACES = INSTALL_SURFACES;
+const INSTALL_PROFILE_ENV_KEY = "MONEYSIREN_INSTALL_PROFILE_PATH";
+export function resolveInstallProfilePath(options = {}) {
+    if (options.path !== undefined && options.path.trim().length > 0) {
+        return resolveInstallPath(options.path, process.cwd());
+    }
+    const env = options.env ?? process.env;
+    const configuredPath = env[INSTALL_PROFILE_ENV_KEY];
+    if (configuredPath !== undefined && configuredPath.trim().length > 0) {
+        return resolveInstallPath(configuredPath, process.cwd());
+    }
+    return defaultInstallProfilePath(env, options.platform ?? process.platform);
+}
+export async function readInstallProfileFile(options = {}) {
+    try {
+        return parseInstallProfile(JSON.parse(await readFile(resolveInstallProfilePath(options), "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeInstallProfileFile(input, options = {}) {
+    const existing = await readInstallProfileFile(options);
+    const now = (options.now ?? (() => new Date()))().toISOString();
+    const profile = {
+        version: 1,
+        selectedSurfaces: normalizeInstallSurfaces(input.selectedSurfaces),
+        recommendedDefault: input.recommendedDefault ?? isRecommendedInstallSelection(input.selectedSurfaces),
+        localOnly: true,
+        secretsReturned: false,
+        source: input.source,
+        installedAt: existing?.installedAt ?? now,
+        updatedAt: now,
+    };
+    const path = resolveInstallProfilePath(options);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(profile, null, 2)}\n`, "utf8");
+    return profile;
+}
+export function parseInstallProfile(value) {
+    if (!isRecord(value) || value.version !== 1) {
+        return null;
+    }
+    const selectedSurfaces = parseInstallSurfaces(value.selectedSurfaces);
+    if (selectedSurfaces.length === 0) {
+        return null;
+    }
+    return {
+        version: 1,
+        selectedSurfaces,
+        recommendedDefault: typeof value.recommendedDefault === "boolean"
+            ? value.recommendedDefault
+            : isRecommendedInstallSelection(selectedSurfaces),
+        localOnly: true,
+        secretsReturned: false,
+        source: value.source === "postinstall" ? "postinstall" : "cli",
+        installedAt: typeof value.installedAt === "string" ? value.installedAt : "",
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : "",
+    };
+}
+export function parseInstallSurfaces(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return normalizeInstallSurfaces(value.filter(isInstallSurface));
+}
+export function normalizeInstallSurfaces(values) {
+    const selected = new Set(values);
+    return INSTALL_SURFACES.filter((surface) => selected.has(surface));
+}
+export function isRecommendedInstallSelection(values) {
+    const selected = normalizeInstallSurfaces(values);
+    return selected.length === INSTALL_SURFACES.length &&
+        INSTALL_SURFACES.every((surface, index) => selected[index] === surface);
+}
+export function formatInstallSurfaces(values) {
+    return normalizeInstallSurfaces(values).map(installSurfaceLabel).join(", ");
+}
+export function installSurfaceLabel(surface) {
+    if (surface === "cli") {
+        return "CLI";
+    }
+    if (surface === "web") {
+        return "Web dashboard";
+    }
+    return "HUD";
+}
+export function isInstallSurface(value) {
+    return typeof value === "string" && INSTALL_SURFACES.includes(value);
+}
+function defaultInstallProfilePath(env, platform) {
+    if (platform === "darwin") {
+        return joinForPlatform(platform, resolveHomeDirectory(env), "Library", "Application Support", "MoneySiren", "install-profile.json");
+    }
+    if (platform === "win32") {
+        return joinForPlatform(platform, resolveWindowsAppDataDirectory(env), "MoneySiren", "install-profile.json");
+    }
+    const configHome = trimToNull(env.XDG_CONFIG_HOME) ?? joinForPlatform(platform, resolveHomeDirectory(env), ".config");
+    return joinForPlatform(platform, configHome, "moneysiren", "install-profile.json");
+}
+function resolveInstallPath(path, cwd) {
+    return isAbsolute(path) ? path : join(cwd, path);
+}
+function resolveWindowsAppDataDirectory(env) {
+    return trimToNull(env.APPDATA) ?? win32.join(resolveHomeDirectory(env), "AppData", "Roaming");
+}
+function resolveHomeDirectory(env) {
+    return trimToNull(env.HOME) ?? trimToNull(env.USERPROFILE) ?? homedir();
+}
+function trimToNull(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed.length === 0 ? null : trimmed;
+}
+function joinForPlatform(platform, ...segments) {
+    return platform === "win32" ? win32.join(...segments) : posix.join(...segments);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=install-profile.js.map

package/dist/apps/cli/src/install-selector.d.ts

@@ -0,0 +1,10 @@
+import { type InstallSurface } from "./install-profile.js";
+export interface InstallSelectionPromptOptions {
+    stdin: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+}
+export declare function promptForInstallSurfaces(options: InstallSelectionPromptOptions): Promise<readonly InstallSurface[]>;
+export declare function parseInstallSurfaceSelection(input: string): readonly InstallSurface[] | null;
+export declare function formatInstallSelectionLine(selectedSurfaces: readonly InstallSurface[]): string;
+export declare function installSelectionHelp(): string;
+//# sourceMappingURL=install-selector.d.ts.map

package/dist/apps/cli/src/install-selector.js

@@ -0,0 +1,66 @@
+import { createInterface } from "node:readline/promises";
+import { DEFAULT_INSTALL_SURFACES, INSTALL_SURFACES, formatInstallSurfaces, installSurfaceLabel, isInstallSurface, normalizeInstallSurfaces, } from "./install-profile.js";
+export async function promptForInstallSurfaces(options) {
+    options.output.write([
+        "MoneySiren setup",
+        "Recommended default: CLI, Web dashboard, HUD",
+        "Select components to enable after npm install:",
+        "  1. CLI",
+        "  2. Web dashboard",
+        "  3. HUD",
+        "",
+    ].join("\n"));
+    options.output.write("\n");
+    const readline = createInterface({
+        input: options.stdin,
+        output: options.output,
+    });
+    try {
+        const answer = await readline.question("Choose components [1,2,3] (Enter = all recommended): ");
+        const selected = parseInstallSurfaceSelection(answer);
+        if (selected === null) {
+            options.output.write("Invalid selection. Using recommended default: CLI, Web dashboard, HUD\n");
+            return DEFAULT_INSTALL_SURFACES;
+        }
+        return selected;
+    }
+    finally {
+        readline.close();
+    }
+}
+export function parseInstallSurfaceSelection(input) {
+    const trimmed = input.trim().toLowerCase();
+    if (trimmed.length === 0 || trimmed === "all" || trimmed === "recommended") {
+        return DEFAULT_INSTALL_SURFACES;
+    }
+    const selected = trimmed
+        .split(/[\s,;]+/)
+        .filter((token) => token.length > 0)
+        .map(selectionTokenToSurface);
+    if (selected.some((surface) => surface === null)) {
+        return null;
+    }
+    const normalized = normalizeInstallSurfaces(selected.filter((surface) => surface !== null));
+    return normalized.length === 0 ? null : normalized;
+}
+export function formatInstallSelectionLine(selectedSurfaces) {
+    return `Selected components: ${formatInstallSurfaces(selectedSurfaces)}`;
+}
+export function installSelectionHelp() {
+    return INSTALL_SURFACES
+        .map((surface, index) => `  ${index + 1}. ${installSurfaceLabel(surface)}`)
+        .join("\n");
+}
+function selectionTokenToSurface(token) {
+    if (token === "1") {
+        return "cli";
+    }
+    if (token === "2") {
+        return "web";
+    }
+    if (token === "3") {
+        return "hud";
+    }
+    return isInstallSurface(token) ? token : null;
+}
+//# sourceMappingURL=install-selector.js.map

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

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

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

@@ -0,0 +1,32 @@
+import { createInterface } from "node:readline/promises";
+import { isSlashQuit, parseSlashInput } from "./slash.js";
+export async function runSlashPrompt(context, execute) {
+    if (context.stdin === undefined || context.output === undefined) {
+        return 0;
+    }
+    const prompt = context.theme.command("moneysiren> ");
+    const readline = createInterface({
+        input: context.stdin,
+        output: context.output,
+        terminal: false,
+        historySize: 0,
+    });
+    context.stdout("Slash prompt ready. Type /help for commands or /quit to exit.");
+    try {
+        let lastExitCode = 0;
+        while (true) {
+            const args = parseSlashInput(await readline.question(prompt));
+            if (args.length === 0) {
+                continue;
+            }
+            lastExitCode = await execute(args);
+            if (isSlashQuit(args)) {
+                return lastExitCode;
+            }
+        }
+    }
+    finally {
+        readline.close();
+    }
+}
+//# sourceMappingURL=interactive.js.map

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=postinstall.d.ts.map

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

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { DEFAULT_INSTALL_SURFACES, writeInstallProfileFile } from "./install-profile.js";
+import { formatInstallSelectionLine, promptForInstallSurfaces } from "./install-selector.js";
+const selectedSurfaces = await selectSurfaces();
+try {
+    const profile = await writeInstallProfileFile({
+        selectedSurfaces,
+        source: "postinstall",
+        recommendedDefault: selectedSurfaces.length === DEFAULT_INSTALL_SURFACES.length,
+    });
+    console.log("MoneySiren setup profile saved.");
+    console.log(formatInstallSelectionLine(profile.selectedSurfaces));
+    console.log("Run `moneysiren install --status` to review or `moneysiren install` to change it.");
+}
+catch (error) {
+    console.warn(`MoneySiren setup profile skipped: ${error instanceof Error ? error.message : String(error)}`);
+}
+async function selectSurfaces() {
+    if (isTruthy(process.env.MONEYSIREN_SKIP_POSTINSTALL)) {
+        return DEFAULT_INSTALL_SURFACES;
+    }
+    if (!shouldPrompt()) {
+        return DEFAULT_INSTALL_SURFACES;
+    }
+    return promptForInstallSurfaces({
+        stdin: process.stdin,
+        output: process.stdout,
+    });
+}
+function shouldPrompt() {
+    return Boolean(process.stdin.isTTY) &&
+        Boolean(process.stdout.isTTY) &&
+        !isTruthy(process.env.CI);
+}
+function isTruthy(value) {
+    if (value === undefined) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 && normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+//# sourceMappingURL=postinstall.js.map

package/dist/apps/cli/src/runtime-adapter.d.ts

@@ -0,0 +1,24 @@
+import { type LocalRuntime } from "../../../packages/runtime/src/index.js";
+import type { CliExecutionContext } from "./cli.js";
+export type { LocalRuntime } from "../../../packages/runtime/src/index.js";
+export interface StartRuntimeOptions {
+    openBrowser?: boolean;
+    port?: number;
+    headless?: boolean;
+}
+export type StartRuntimeResult = {
+    status: "running" | "started";
+    runtime: LocalRuntime;
+} | {
+    status: "unavailable";
+    reason: string;
+    guidance: readonly string[];
+};
+export interface CliLocalRuntimeAdapter {
+    findRuntime(): Promise<LocalRuntime | null>;
+    assertRuntimeHealthy(runtime: LocalRuntime): Promise<boolean>;
+    startRuntime(options: StartRuntimeOptions): Promise<StartRuntimeResult>;
+}
+export declare function createFallbackLocalRuntimeAdapter(context: CliExecutionContext): CliLocalRuntimeAdapter;
+export declare function openUrlInBrowser(url: string): Promise<void>;
+//# sourceMappingURL=runtime-adapter.d.ts.map

package/dist/apps/cli/src/runtime-adapter.js

@@ -0,0 +1,185 @@
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { startLocalApiServer } from "../../../packages/local-api/src/index.js";
+import { assertRuntimeHealthy as assertPackageRuntimeHealthy, findRuntime, } from "../../../packages/runtime/src/index.js";
+import { readLocalStore } from "../../../packages/db/src/index.js";
+import { loadCliConfig, resolveDbPath } from "./commands/shared.js";
+let activeLocalApiServer = null;
+let registeredShutdownHandlers = false;
+export function createFallbackLocalRuntimeAdapter(context) {
+    return {
+        async findRuntime() {
+            return findRuntime({
+                cwd: context.cwd,
+                env: context.env,
+            });
+        },
+        async assertRuntimeHealthy(runtime) {
+            return assertPackageRuntimeHealthy(runtime, {
+                fetchImpl: context.fetch,
+            });
+        },
+        async startRuntime(options) {
+            const runtime = await findRuntime({
+                cwd: context.cwd,
+                env: context.env,
+            });
+            if (runtime !== null && await assertPackageRuntimeHealthy(runtime, {
+                fetchImpl: context.fetch,
+            })) {
+                return {
+                    status: "running",
+                    runtime,
+                };
+            }
+            if (activeLocalApiServer !== null) {
+                return {
+                    status: "running",
+                    runtime: activeLocalApiServer.runtime,
+                };
+            }
+            const api = await startLocalApiServer({
+                ...(options.port === undefined ? {} : { port: options.port }),
+                runtimeLock: {
+                    cwd: context.cwd,
+                    env: context.env,
+                },
+                viewModel: {
+                    now: context.now,
+                    readStore: () => readViewModelStore(context),
+                },
+            });
+            activeLocalApiServer = api;
+            registerShutdownHandlers();
+            return {
+                status: "started",
+                runtime: api.runtime,
+            };
+        },
+    };
+}
+export async function openUrlInBrowser(url) {
+    const parsedUrl = new URL(url);
+    if (!isLoopbackHttpUrl(parsedUrl)) {
+        throw new Error("Refusing to open a non-loopback runtime URL.");
+    }
+    const child = process.platform === "win32"
+        ? spawn("cmd", ["/c", "start", "", parsedUrl.toString()], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        })
+        : process.platform === "darwin"
+            ? spawn("open", [parsedUrl.toString()], {
+                detached: true,
+                stdio: "ignore",
+            })
+            : spawn("xdg-open", [parsedUrl.toString()], {
+                detached: true,
+                stdio: "ignore",
+            });
+    child.unref();
+}
+function isLoopbackHttpUrl(url) {
+    return url.protocol === "http:" &&
+        (url.hostname === "127.0.0.1" ||
+            url.hostname === "localhost" ||
+            url.hostname === "::1" ||
+            url.hostname === "[::1]");
+}
+async function readViewModelStore(context) {
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    if (!await pathExists(dbPath)) {
+        return emptyViewModelStore();
+    }
+    return localStoreToViewModelStore(await readLocalStore({ dbPath }));
+}
+function localStoreToViewModelStore(store) {
+    return {
+        providers: store.providers.map((provider) => ({
+            key: provider.key,
+            displayName: provider.displayName,
+        })),
+        usageSnapshots: store.usageSnapshots.map((snapshot) => ({
+            providerKey: snapshot.providerKey,
+            collectedAt: snapshot.collectedAt,
+            service: snapshot.service,
+            metric: snapshot.metric,
+            unit: snapshot.unit,
+            value: snapshot.value,
+        })),
+        billingSnapshots: store.billingSnapshots.map((snapshot) => ({
+            providerKey: snapshot.providerKey,
+            collectedAt: snapshot.collectedAt,
+            amountMinor: snapshot.amountMinor,
+            currency: snapshot.currency,
+            status: snapshot.status,
+        })),
+        serviceHealthSnapshots: store.serviceHealthSnapshots.map((snapshot) => ({
+            providerKey: snapshot.providerKey,
+            collectedAt: snapshot.collectedAt,
+            service: snapshot.service,
+            status: snapshot.status,
+            ...(snapshot.region === undefined ? {} : { region: snapshot.region }),
+            ...(snapshot.message === undefined ? {} : { message: snapshot.message }),
+        })),
+        costEstimates: store.costEstimates.map((estimate) => ({
+            providerKey: estimate.providerKey,
+            collectedAt: estimate.collectedAt,
+            estimatedAmountMinor: estimate.estimatedAmountMinor,
+            currency: estimate.currency,
+            confidence: estimate.confidence,
+        })),
+        alerts: store.alerts.map((alert) => ({
+            ...(alert.providerKey === undefined ? {} : { providerKey: alert.providerKey }),
+            createdAt: alert.createdAt,
+            severity: alert.severity,
+            category: alert.category,
+            title: alert.title,
+            message: alert.message,
+        })),
+    };
+}
+function emptyViewModelStore() {
+    return {
+        providers: [],
+        usageSnapshots: [],
+        billingSnapshots: [],
+        serviceHealthSnapshots: [],
+        costEstimates: [],
+        alerts: [],
+    };
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function registerShutdownHandlers() {
+    if (registeredShutdownHandlers) {
+        return;
+    }
+    registeredShutdownHandlers = true;
+    const closeActiveServer = () => {
+        const server = activeLocalApiServer;
+        activeLocalApiServer = null;
+        if (server !== null) {
+            void server.close();
+        }
+    };
+    process.once("beforeExit", closeActiveServer);
+    process.once("SIGINT", () => {
+        closeActiveServer();
+        process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+        closeActiveServer();
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=runtime-adapter.js.map

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

@@ -0,0 +1,15 @@
+type SlashDispatch = {
+    kind: "dispatch";
+    args: readonly string[];
+} | {
+    kind: "quit";
+} | {
+    kind: "error";
+    message: string;
+    usage?: string;
+};
+export declare function parseSlashInput(input: string): readonly string[];
+export declare function isSlashQuit(args: readonly string[]): boolean;
+export declare function resolveSlashCommand(args: readonly string[]): SlashDispatch;
+export {};
+//# sourceMappingURL=slash.d.ts.map