@moneysiren/app 0.1.0-alpha.9

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

@@ -0,0 +1,430 @@
+import { stat } from "node:fs/promises";
+import { sendSlackReport } from "../../../../packages/report/src/index.js";
+import { NOTIFICATION_WIDGET_KEYS, readNotificationPreferencesFile, resolveNotificationPreferencesPath, writeNotificationPreferencesFile, } from "../../../../packages/view-model/src/index.js";
+import { readSanitizedNotificationDigest } from "../summary-model.js";
+import { loadCliConfig } from "./shared.js";
+const NOTIFY_USAGE = [
+    "Usage:",
+    "  moneysiren notify once --dry-run",
+    "  moneysiren notify prefs list",
+    "  moneysiren notify prefs enable <widget>",
+    "  moneysiren notify prefs disable <widget>",
+    "  moneysiren notify prefs hud-enable <widget>",
+    "  moneysiren notify prefs hud-disable <widget>",
+    "  moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>",
+    "  moneysiren notify prefs quiet-hours <start> <end>",
+    "  moneysiren notify test",
+].join("\n");
+const NOTIFY_PREFS_USAGE = [
+    "Usage:",
+    "  moneysiren notify prefs list",
+    "  moneysiren notify prefs enable <widget>",
+    "  moneysiren notify prefs disable <widget>",
+    "  moneysiren notify prefs hud-enable <widget>",
+    "  moneysiren notify prefs hud-disable <widget>",
+    "  moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>",
+    "  moneysiren notify prefs quiet-hours <start> <end>",
+].join("\n");
+export async function runNotifyCommand(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        context.stdout(NOTIFY_USAGE);
+        return 0;
+    }
+    if (subcommand === "once") {
+        return runNotifyOnce(rest, context);
+    }
+    if (subcommand === "prefs") {
+        return runNotifyPrefs(rest, context);
+    }
+    if (subcommand === "test") {
+        return runNotifyTest(rest, context);
+    }
+    context.stderr(NOTIFY_USAGE);
+    return 1;
+}
+async function runNotifyOnce(args, context) {
+    if (args.length !== 1 || args[0] !== "--dry-run") {
+        context.stderr("Usage: moneysiren notify once --dry-run");
+        return 1;
+    }
+    const digest = await readSanitizedNotificationDigest(context);
+    context.stdout("MoneySiren notification dry run");
+    context.stdout(`Generated at: ${digest.generatedAt}`);
+    context.stdout(`Secrets returned: ${digest.secretsReturned}`);
+    context.stdout(`Providers: ${digest.providerCount}`);
+    context.stdout(`Health: ${digest.health}`);
+    context.stdout(`Alerts: ${digest.alertCount}`);
+    context.stdout(`Critical alerts: ${digest.criticalAlertCount}`);
+    if (digest.estimatedAmountMinorByCurrency.length === 0) {
+        context.stdout("Estimated totals: none");
+        return 0;
+    }
+    for (const total of digest.estimatedAmountMinorByCurrency) {
+        context.stdout(`Estimated total ${total.currency}: ${formatMinorAmount(total.amountMinor)}`);
+    }
+    return 0;
+}
+async function runNotifyPrefs(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "list" && rest.length === 0) {
+        return listNotificationPreferences(context);
+    }
+    if (subcommand === "enable" && rest.length === 1) {
+        return enableNotificationWidget(rest[0], context);
+    }
+    if (subcommand === "disable" && rest.length === 1) {
+        return disableNotificationWidget(rest[0], context);
+    }
+    if (subcommand === "hud-enable" && rest.length === 1) {
+        return enableHudWidget(rest[0], context);
+    }
+    if (subcommand === "hud-disable" && rest.length === 1) {
+        return disableHudWidget(rest[0], context);
+    }
+    if (subcommand === "threshold") {
+        return setNotificationThreshold(rest, context);
+    }
+    if (subcommand === "quiet-hours" && rest.length === 2) {
+        return setNotificationQuietHours(rest[0], rest[1], context);
+    }
+    context.stderr(NOTIFY_PREFS_USAGE);
+    return 1;
+}
+async function listNotificationPreferences(context) {
+    const source = await notificationPreferencesSource(context);
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    const hudWidgets = new Set(preferences.hud.selectedWidgets);
+    context.stdout("MoneySiren notification preferences");
+    context.stdout(`Source: ${source}`);
+    context.stdout("Secrets returned: false");
+    context.stdout(`Notifications: ${enabledLabel(preferences.enabled)}`);
+    context.stdout(`Digest: ${enabledLabel(preferences.digestEnabled)} (${preferences.digestInterval})`);
+    context.stdout(`Desktop notifications: ${enabledLabel(preferences.desktopEnabled)}`);
+    context.stdout(`HUD font size: ${Math.round(preferences.hud.fontScale * 100)}%`);
+    context.stdout(`HUD opacity: ${Math.round(preferences.hud.opacity * 100)}%`);
+    context.stdout(`Quiet hours: ${preferences.quietHours.start}-${preferences.quietHours.end}`);
+    context.stdout("Widgets:");
+    for (const widgetKey of NOTIFICATION_WIDGET_KEYS) {
+        context.stdout(`- ${widgetKey}: ${selectedWidgets.has(widgetKey) ? "enabled" : "disabled"}`);
+    }
+    context.stdout("HUD widgets:");
+    for (const widgetKey of NOTIFICATION_WIDGET_KEYS) {
+        context.stdout(`- ${widgetKey}: ${hudWidgets.has(widgetKey) ? "enabled" : "disabled"}`);
+    }
+    if (preferences.thresholdRules.length === 0) {
+        context.stdout("Thresholds: none configured");
+        return 0;
+    }
+    context.stdout("Thresholds:");
+    for (const rule of orderThresholdRules(preferences.thresholdRules)) {
+        context.stdout(`- ${rule.widgetKey}: ${rule.operator} ${formatRuleValue(rule.value)} cooldown ${rule.cooldownMinutes}m`);
+    }
+    return 0;
+}
+async function enableNotificationWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    selectedWidgets.add(widgetKey);
+    await writePreferences({
+        ...preferences,
+        selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+    }, context);
+    context.stdout(`Notification widget enabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function disableNotificationWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    if (!selectedWidgets.has(widgetKey)) {
+        context.stdout(`Notification widget already disabled: ${widgetKey}`);
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    selectedWidgets.delete(widgetKey);
+    if (selectedWidgets.size === 0) {
+        context.stderr("At least one notification widget must remain enabled.");
+        return 1;
+    }
+    await writePreferences({
+        ...preferences,
+        selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+    }, context);
+    context.stdout(`Notification widget disabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function enableHudWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.hud.selectedWidgets);
+    selectedWidgets.add(widgetKey);
+    await writePreferences({
+        ...preferences,
+        hud: {
+            ...preferences.hud,
+            selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+        },
+    }, context);
+    context.stdout(`HUD widget enabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function disableHudWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.hud.selectedWidgets);
+    if (!selectedWidgets.has(widgetKey)) {
+        context.stdout(`HUD widget already disabled: ${widgetKey}`);
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    selectedWidgets.delete(widgetKey);
+    if (selectedWidgets.size === 0) {
+        context.stderr("At least one HUD widget must remain enabled.");
+        return 1;
+    }
+    await writePreferences({
+        ...preferences,
+        hud: {
+            ...preferences.hud,
+            selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+        },
+    }, context);
+    context.stdout(`HUD widget disabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function setNotificationThreshold(args, context) {
+    const [widget, ...flagArgs] = args;
+    const widgetKey = parseWidgetKey(widget);
+    const parsedRule = parseThresholdRuleArgs(widgetKey, flagArgs);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    if (parsedRule === undefined) {
+        context.stderr("Usage: moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    await writePreferences({
+        ...preferences,
+        thresholdRules: orderThresholdRules([
+            ...preferences.thresholdRules.filter((rule) => rule.widgetKey !== widgetKey),
+            parsedRule,
+        ]),
+    }, context);
+    context.stdout(`Notification threshold set: ${parsedRule.widgetKey} ${parsedRule.operator} ${formatRuleValue(parsedRule.value)} cooldown ${parsedRule.cooldownMinutes}m`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function setNotificationQuietHours(start, end, context) {
+    if (!isValidClockTime(start) || !isValidClockTime(end)) {
+        context.stderr("Usage: moneysiren notify prefs quiet-hours <HH:MM> <HH:MM>");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    await writePreferences({
+        ...preferences,
+        quietHours: {
+            start,
+            end,
+        },
+    }, context);
+    context.stdout(`Notification quiet hours set: ${start}-${end}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function runNotifyTest(args, context) {
+    if (args.length !== 0) {
+        context.stderr("Usage: moneysiren notify test");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const webhookEnvKey = config.slack.requiredEnvKey;
+    const webhookUrl = context.env[webhookEnvKey]?.trim();
+    if (webhookUrl === undefined || webhookUrl.length === 0) {
+        context.stderr(`${webhookEnvKey} is required for test notification.`);
+        return 1;
+    }
+    const text = [
+        "MoneySiren test notification",
+        `Generated at: ${context.now().toISOString()}`,
+        "Secrets returned: false",
+    ].join("\n");
+    try {
+        const options = context.slackTransport === undefined
+            ? {
+                webhookUrl,
+                text,
+            }
+            : {
+                webhookUrl,
+                text,
+                transport: context.slackTransport,
+            };
+        await sendSlackReport(options);
+        context.stdout("MoneySiren test notification sent");
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    catch (error) {
+        context.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function formatMinorAmount(amountMinor) {
+    return (amountMinor / 100).toFixed(2);
+}
+async function readPreferences(context) {
+    return readNotificationPreferencesFile({
+        cwd: context.cwd,
+        env: context.env,
+    });
+}
+async function writePreferences(preferences, context) {
+    return writeNotificationPreferencesFile(preferences, {
+        cwd: context.cwd,
+        env: context.env,
+    });
+}
+async function notificationPreferencesSource(context) {
+    const path = resolveNotificationPreferencesPath({
+        cwd: context.cwd,
+        env: context.env,
+    });
+    try {
+        await stat(path);
+        return "local preference file";
+    }
+    catch {
+        return "default preference template";
+    }
+}
+function parseWidgetKey(value) {
+    return value !== undefined && NOTIFICATION_WIDGET_KEYS.includes(value)
+        ? value
+        : undefined;
+}
+function parseThresholdRuleArgs(widgetKey, args) {
+    if (widgetKey === undefined) {
+        return undefined;
+    }
+    let operator;
+    let value;
+    let cooldownMinutes;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined) {
+            return undefined;
+        }
+        const operatorName = parseOperatorFlag(arg);
+        if (operatorName !== undefined) {
+            if (operator !== undefined) {
+                return undefined;
+            }
+            const inlineValue = inlineFlagValue(arg);
+            const rawValue = inlineValue ?? args[index + 1];
+            value = parseNonNegativeNumber(rawValue);
+            operator = operatorName;
+            if (inlineValue === undefined) {
+                index += 1;
+            }
+            continue;
+        }
+        if (arg === "--cooldown" || arg.startsWith("--cooldown=")) {
+            const inlineValue = inlineFlagValue(arg);
+            const rawValue = inlineValue ?? args[index + 1];
+            cooldownMinutes = parseNonNegativeInteger(rawValue);
+            if (inlineValue === undefined) {
+                index += 1;
+            }
+            continue;
+        }
+        return undefined;
+    }
+    if (operator === undefined || value === undefined || cooldownMinutes === undefined) {
+        return undefined;
+    }
+    return {
+        widgetKey,
+        operator,
+        value,
+        cooldownMinutes,
+    };
+}
+function parseOperatorFlag(value) {
+    if (value === "--gte" || value.startsWith("--gte=")) {
+        return "gte";
+    }
+    if (value === "--lte" || value.startsWith("--lte=")) {
+        return "lte";
+    }
+    if (value === "--eq" || value.startsWith("--eq=")) {
+        return "eq";
+    }
+    return undefined;
+}
+function inlineFlagValue(value) {
+    const separatorIndex = value.indexOf("=");
+    return separatorIndex === -1 ? undefined : value.slice(separatorIndex + 1);
+}
+function parseNonNegativeNumber(value) {
+    if (value === undefined || value.trim().length === 0) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function parseNonNegativeInteger(value) {
+    const parsed = parseNonNegativeNumber(value);
+    return parsed !== undefined && Number.isInteger(parsed) ? parsed : undefined;
+}
+function orderWidgetKeys(widgetKeys) {
+    const selected = new Set(widgetKeys);
+    return NOTIFICATION_WIDGET_KEYS.filter((widgetKey) => selected.has(widgetKey));
+}
+function orderThresholdRules(rules) {
+    const byWidgetKey = new Map(rules.map((rule) => [rule.widgetKey, rule]));
+    return NOTIFICATION_WIDGET_KEYS.flatMap((widgetKey) => {
+        const rule = byWidgetKey.get(widgetKey);
+        return rule === undefined ? [] : [rule];
+    });
+}
+function enabledLabel(value) {
+    return value ? "enabled" : "disabled";
+}
+function formatRuleValue(value) {
+    return String(value);
+}
+function isValidClockTime(value) {
+    if (value === undefined || !/^\d{2}:\d{2}$/.test(value)) {
+        return false;
+    }
+    const [hourText, minuteText] = value.split(":");
+    const hour = Number(hourText);
+    const minute = Number(minuteText);
+    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+}
+//# sourceMappingURL=notify.js.map

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

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

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,10 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runServeCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runStatusCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runStartCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runStopCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runRestartCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+export declare function runHudCommand(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