@moneysiren/app 0.1.0-alpha.9

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

@@ -0,0 +1,393 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { collectProviderSnapshots } from "../../../../packages/core/src/index.js";
+import { createAwsCostExplorerConnector, createAwsSdkCostExplorerClient, createStaticCostExplorerClient, } from "../../../../packages/connectors/aws/src/index.js";
+import { createMockProviderConnector } from "../../../../packages/connectors/mock/src/index.js";
+import { createOpenAiUsageCostsClient, createOpenAiUsageCostsConnector, createStaticOpenAiUsageCostsClient, } from "../../../../packages/connectors/openai/src/index.js";
+import { createSupabaseManagementClient, createStaticSupabaseUsageHealthClient, createSupabaseUsageHealthConnector, } from "../../../../packages/connectors/supabase/src/index.js";
+import { createCloudflareBillingUsageClient, createCloudflareBillingUsageConnector, createStaticCloudflareBillingUsageClient, } from "../../../../packages/connectors/cloudflare/src/index.js";
+import { initializeLocalStore, saveLocalProviderCollection } from "../../../../packages/db/src/index.js";
+import { loadCliConfig, readFlag, resolveDbPath } from "./shared.js";
+const AWS_COST_EXPLORER_FIXTURE_ENV_KEY = "MONEYSIREN_AWS_COST_EXPLORER_FIXTURE";
+const AWS_REGION_ENV_KEY = "MONEYSIREN_AWS_REGION";
+const OPENAI_USAGE_FIXTURE_ENV_KEY = "MONEYSIREN_OPENAI_USAGE_FIXTURE";
+const OPENAI_COSTS_FIXTURE_ENV_KEY = "MONEYSIREN_OPENAI_COSTS_FIXTURE";
+const SUPABASE_FIXTURE_ENV_KEY = "MONEYSIREN_SUPABASE_FIXTURE";
+const CLOUDFLARE_FIXTURE_ENV_KEY = "MONEYSIREN_CLOUDFLARE_FIXTURE";
+const CLOUDFLARE_ACCOUNT_IDS_ENV_KEY = "CLOUDFLARE_ACCOUNT_IDS";
+const SYNC_USAGE = "Usage: moneysiren sync --provider <mock|aws|openai|supabase|cloudflare> [--profile <aws-profile>]";
+export async function runSyncCommand(args, context) {
+    const providerFlag = readFlag(args, "--provider");
+    const awsProfileOption = readAwsProfileOption(providerFlag.remainingArgs);
+    if (awsProfileOption.error !== undefined ||
+        awsProfileOption.remainingArgs.length > 0 ||
+        providerFlag.value === undefined ||
+        !isSupportedSyncProvider(providerFlag.value)) {
+        context.stderr(awsProfileOption.error ?? SYNC_USAGE);
+        return 1;
+    }
+    if (providerFlag.value !== "aws" && awsProfileOption.profile !== undefined) {
+        context.stderr("--profile is only supported for AWS sync.");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    if (providerFlag.value === "aws") {
+        const awsEnv = applyAwsProfileOption(context.env, awsProfileOption.profile);
+        const fixturePath = readConfiguredEnvValue(awsEnv[AWS_COST_EXPLORER_FIXTURE_ENV_KEY]);
+        if (fixturePath !== undefined) {
+            return syncAwsProvider(context, config.dbPath, createStaticCostExplorerClient(await loadAwsFixture(context.cwd, fixturePath)));
+        }
+        if (!isAwsLiveConfigured(awsEnv) && context.liveClients?.awsCostExplorer === undefined) {
+            context.stderr(`AWS sync requires AWS_PROFILE, --profile <profile>, AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY, or ` +
+                `${AWS_COST_EXPLORER_FIXTURE_ENV_KEY}. If you ran aws sso login --profile <profile>, pass ` +
+                `--profile <profile> or set AWS_PROFILE in this shell.`);
+            return 1;
+        }
+        return withAwsProfileOnProcessEnv(awsProfileOption.profile, () => syncAwsProvider(context, config.dbPath, context.liveClients?.awsCostExplorer ?? createAwsSdkCostExplorerClient(awsSdkOptionsFromEnv(awsEnv))));
+    }
+    if (providerFlag.value === "openai") {
+        const usageFixturePath = readConfiguredEnvValue(context.env[OPENAI_USAGE_FIXTURE_ENV_KEY]);
+        const costsFixturePath = readConfiguredEnvValue(context.env[OPENAI_COSTS_FIXTURE_ENV_KEY]);
+        if (usageFixturePath !== undefined || costsFixturePath !== undefined) {
+            if (usageFixturePath === undefined || costsFixturePath === undefined) {
+                context.stderr(`OpenAI fixture sync requires both ${OPENAI_USAGE_FIXTURE_ENV_KEY} and ${OPENAI_COSTS_FIXTURE_ENV_KEY}.`);
+                return 1;
+            }
+            return syncOpenAiProvider(context, config.dbPath, createStaticOpenAiUsageCostsClient(await loadOpenAiUsageCostsFixture(context.cwd, usageFixturePath, costsFixturePath)));
+        }
+        if (!config.providers.openai.configured && context.liveClients?.openaiUsageCosts === undefined) {
+            context.stderr(`OpenAI sync requires OPENAI_ADMIN_KEY or fixture mode with ${OPENAI_USAGE_FIXTURE_ENV_KEY} ` +
+                `and ${OPENAI_COSTS_FIXTURE_ENV_KEY}.`);
+            return 1;
+        }
+        return syncOpenAiProvider(context, config.dbPath, context.liveClients?.openaiUsageCosts ?? createOpenAiUsageCostsClient({
+            adminKey: requireConfiguredEnvValue(context.env.OPENAI_ADMIN_KEY, "OPENAI_ADMIN_KEY"),
+        }));
+    }
+    if (providerFlag.value === "supabase") {
+        const fixturePath = readConfiguredEnvValue(context.env[SUPABASE_FIXTURE_ENV_KEY]);
+        if (fixturePath !== undefined) {
+            return syncSupabaseProvider(context, config.dbPath, createStaticSupabaseUsageHealthClient(await loadSupabaseFixture(context.cwd, fixturePath)));
+        }
+        if (!config.providers.supabase.configured && context.liveClients?.supabaseUsageHealth === undefined) {
+            context.stderr(`Supabase sync requires SUPABASE_ACCESS_TOKEN or ${SUPABASE_FIXTURE_ENV_KEY}. ` +
+                `Set ${SUPABASE_FIXTURE_ENV_KEY} for fixture mode.`);
+            return 1;
+        }
+        return syncSupabaseProvider(context, config.dbPath, context.liveClients?.supabaseUsageHealth ?? createSupabaseManagementClient({
+            accessToken: requireConfiguredEnvValue(context.env.SUPABASE_ACCESS_TOKEN, "SUPABASE_ACCESS_TOKEN"),
+        }));
+    }
+    if (providerFlag.value === "cloudflare") {
+        const fixturePath = readConfiguredEnvValue(context.env[CLOUDFLARE_FIXTURE_ENV_KEY]);
+        if (fixturePath !== undefined) {
+            return syncCloudflareProvider(context, config.dbPath, createStaticCloudflareBillingUsageClient(await loadCloudflareFixture(context.cwd, fixturePath)));
+        }
+        if (!config.providers.cloudflare.configured && context.liveClients?.cloudflareBillingUsage === undefined) {
+            context.stderr(`Cloudflare sync requires CLOUDFLARE_API_TOKEN and ${CLOUDFLARE_ACCOUNT_IDS_ENV_KEY}, or ${CLOUDFLARE_FIXTURE_ENV_KEY}. ` +
+                `Set ${CLOUDFLARE_FIXTURE_ENV_KEY} for fixture mode.`);
+            return 1;
+        }
+        return syncCloudflareProvider(context, config.dbPath, context.liveClients?.cloudflareBillingUsage ?? createCloudflareBillingUsageClient({
+            apiToken: requireConfiguredEnvValue(context.env.CLOUDFLARE_API_TOKEN, "CLOUDFLARE_API_TOKEN"),
+            accountIds: readCloudflareAccountIds(context.env[CLOUDFLARE_ACCOUNT_IDS_ENV_KEY]),
+        }));
+    }
+    return syncMockProvider(context, config.dbPath);
+}
+function isSupportedSyncProvider(provider) {
+    return provider === "mock" || provider === "aws" || provider === "openai" || provider === "supabase" ||
+        provider === "cloudflare";
+}
+async function syncMockProvider(context, configuredDbPath) {
+    const dbPath = resolveDbPath(context.cwd, configuredDbPath);
+    await initializeLocalStore({ dbPath });
+    const connector = createMockProviderConnector();
+    const collection = await collectProviderSnapshots(connector, {
+        now: context.now,
+    });
+    await saveLocalProviderCollection({
+        dbPath,
+        provider: {
+            key: connector.kind,
+            displayName: connector.displayName,
+            connectorVersion: "0.1.0-alpha.0",
+        },
+        collectedAt: collection.collectedAt,
+        status: collection.status,
+        snapshots: collection.snapshots,
+        alerts: collection.alerts,
+    });
+    context.stdout([
+        "Synced mock provider snapshots:",
+        `usage=${collection.snapshots.usage.length}`,
+        `billing=${collection.snapshots.billing.length}`,
+        `health=${collection.snapshots.serviceHealth.length}`,
+        `estimates=${collection.snapshots.costEstimates.length}`,
+        `alerts=${collection.alerts.length}`,
+    ].join(" "));
+    return 0;
+}
+async function syncAwsProvider(context, configuredDbPath, costExplorerClient) {
+    const dbPath = resolveDbPath(context.cwd, configuredDbPath);
+    await initializeLocalStore({ dbPath });
+    const connector = createAwsCostExplorerConnector({
+        costExplorerClient,
+    });
+    const collection = await collectProviderSnapshots(connector, {
+        now: context.now,
+    });
+    await saveLocalProviderCollection({
+        dbPath,
+        provider: {
+            key: connector.kind,
+            displayName: connector.displayName,
+            connectorVersion: "0.1.0-alpha.0",
+        },
+        collectedAt: collection.collectedAt,
+        status: collection.status,
+        snapshots: collection.snapshots,
+        alerts: collection.alerts,
+    });
+    context.stdout([
+        "Synced AWS Cost Explorer snapshots:",
+        `usage=${collection.snapshots.usage.length}`,
+        `billing=${collection.snapshots.billing.length}`,
+        `health=${collection.snapshots.serviceHealth.length}`,
+        `estimates=${collection.snapshots.costEstimates.length}`,
+        `alerts=${collection.alerts.length}`,
+    ].join(" "));
+    if (collection.status === "error") {
+        context.stderr(collection.errors?.[0] ?? collection.alerts[0]?.message ?? "AWS Cost Explorer sync failed.");
+        return 1;
+    }
+    return 0;
+}
+async function loadAwsFixture(cwd, fixturePath) {
+    const resolvedPath = isAbsolute(fixturePath) ? fixturePath : join(cwd, fixturePath);
+    return JSON.parse(await readFile(resolvedPath, "utf8"));
+}
+async function syncOpenAiProvider(context, configuredDbPath, client) {
+    const dbPath = resolveDbPath(context.cwd, configuredDbPath);
+    await initializeLocalStore({ dbPath });
+    const connector = createOpenAiUsageCostsConnector({
+        client,
+    });
+    const collection = await collectProviderSnapshots(connector, {
+        now: context.now,
+    });
+    await saveLocalProviderCollection({
+        dbPath,
+        provider: {
+            key: connector.kind,
+            displayName: connector.displayName,
+            connectorVersion: "0.1.0-alpha.0",
+        },
+        collectedAt: collection.collectedAt,
+        status: collection.status,
+        snapshots: collection.snapshots,
+        alerts: collection.alerts,
+    });
+    context.stdout([
+        "Synced OpenAI usage and costs snapshots:",
+        `usage=${collection.snapshots.usage.length}`,
+        `billing=${collection.snapshots.billing.length}`,
+        `health=${collection.snapshots.serviceHealth.length}`,
+        `estimates=${collection.snapshots.costEstimates.length}`,
+        `alerts=${collection.alerts.length}`,
+    ].join(" "));
+    return 0;
+}
+async function loadOpenAiUsageCostsFixture(cwd, usageFixturePath, costsFixturePath) {
+    const [usage, costs] = await Promise.all([
+        loadOpenAiFixtureSection(cwd, usageFixturePath, "usage"),
+        loadOpenAiFixtureSection(cwd, costsFixturePath, "costs"),
+    ]);
+    return {
+        usage,
+        costs,
+    };
+}
+async function loadOpenAiFixtureSection(cwd, fixturePath, section) {
+    const resolvedPath = isAbsolute(fixturePath) ? fixturePath : join(cwd, fixturePath);
+    const parsed = JSON.parse(await readFile(resolvedPath, "utf8"));
+    if (isRecord(parsed) && section in parsed) {
+        return parsed[section];
+    }
+    return parsed;
+}
+async function syncSupabaseProvider(context, configuredDbPath, client) {
+    const dbPath = resolveDbPath(context.cwd, configuredDbPath);
+    await initializeLocalStore({ dbPath });
+    const connector = createSupabaseUsageHealthConnector({
+        client,
+    });
+    const collection = await collectProviderSnapshots(connector, {
+        now: context.now,
+    });
+    await saveLocalProviderCollection({
+        dbPath,
+        provider: {
+            key: connector.kind,
+            displayName: connector.displayName,
+            connectorVersion: "0.1.0-alpha.0",
+        },
+        collectedAt: collection.collectedAt,
+        status: collection.status,
+        snapshots: collection.snapshots,
+        alerts: collection.alerts,
+    });
+    context.stdout([
+        "Synced Supabase usage and health snapshots:",
+        `usage=${collection.snapshots.usage.length}`,
+        `billing=${collection.snapshots.billing.length}`,
+        `health=${collection.snapshots.serviceHealth.length}`,
+        `estimates=${collection.snapshots.costEstimates.length}`,
+        `alerts=${collection.alerts.length}`,
+    ].join(" "));
+    return 0;
+}
+async function loadSupabaseFixture(cwd, fixturePath) {
+    const resolvedPath = isAbsolute(fixturePath) ? fixturePath : join(cwd, fixturePath);
+    return JSON.parse(await readFile(resolvedPath, "utf8"));
+}
+async function syncCloudflareProvider(context, configuredDbPath, client) {
+    const dbPath = resolveDbPath(context.cwd, configuredDbPath);
+    await initializeLocalStore({ dbPath });
+    const connector = createCloudflareBillingUsageConnector({
+        client,
+    });
+    const collection = await collectProviderSnapshots(connector, {
+        now: context.now,
+    });
+    await saveLocalProviderCollection({
+        dbPath,
+        provider: {
+            key: connector.kind,
+            displayName: connector.displayName,
+            connectorVersion: "0.1.0-alpha.0",
+        },
+        collectedAt: collection.collectedAt,
+        status: collection.status,
+        snapshots: collection.snapshots,
+        alerts: collection.alerts,
+    });
+    context.stdout([
+        "Synced Cloudflare billing and usage snapshots:",
+        `usage=${collection.snapshots.usage.length}`,
+        `billing=${collection.snapshots.billing.length}`,
+        `health=${collection.snapshots.serviceHealth.length}`,
+        `estimates=${collection.snapshots.costEstimates.length}`,
+        `alerts=${collection.alerts.length}`,
+    ].join(" "));
+    return 0;
+}
+async function loadCloudflareFixture(cwd, fixturePath) {
+    const resolvedPath = isAbsolute(fixturePath) ? fixturePath : join(cwd, fixturePath);
+    return JSON.parse(await readFile(resolvedPath, "utf8"));
+}
+function readConfiguredEnvValue(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
+}
+function requireConfiguredEnvValue(value, envKey) {
+    const trimmed = readConfiguredEnvValue(value);
+    if (trimmed === undefined) {
+        throw new Error(`${envKey} must be configured for live sync.`);
+    }
+    return trimmed;
+}
+function isAwsLiveConfigured(env) {
+    return readConfiguredEnvValue(env.AWS_PROFILE) !== undefined ||
+        (readConfiguredEnvValue(env.AWS_ACCESS_KEY_ID) !== undefined &&
+            readConfiguredEnvValue(env.AWS_SECRET_ACCESS_KEY) !== undefined);
+}
+function awsSdkOptionsFromEnv(env) {
+    const region = readConfiguredEnvValue(env[AWS_REGION_ENV_KEY]);
+    return region === undefined ? {} : { region };
+}
+function readAwsProfileOption(args) {
+    const remainingArgs = [];
+    let profile;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--profile" || arg === "--aws-profile") {
+            const value = args[index + 1];
+            const parsed = readConfiguredEnvValue(value);
+            if (parsed === undefined || value?.startsWith("--") === true) {
+                return {
+                    remainingArgs,
+                    error: `${arg} requires a profile name.`,
+                };
+            }
+            if (profile !== undefined && profile !== parsed) {
+                return {
+                    remainingArgs,
+                    error: "AWS profile was provided more than once with different values.",
+                };
+            }
+            profile = parsed;
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--profile=") || arg?.startsWith("--aws-profile=")) {
+            const [flagName, ...valueParts] = arg.split("=");
+            const parsed = readConfiguredEnvValue(valueParts.join("="));
+            if (parsed === undefined) {
+                return {
+                    remainingArgs,
+                    error: `${flagName} requires a profile name.`,
+                };
+            }
+            if (profile !== undefined && profile !== parsed) {
+                return {
+                    remainingArgs,
+                    error: "AWS profile was provided more than once with different values.",
+                };
+            }
+            profile = parsed;
+            continue;
+        }
+        if (arg !== undefined) {
+            remainingArgs.push(arg);
+        }
+    }
+    return profile === undefined ? { remainingArgs } : { profile, remainingArgs };
+}
+function applyAwsProfileOption(env, profile) {
+    if (profile === undefined) {
+        return env;
+    }
+    return {
+        ...env,
+        AWS_PROFILE: profile,
+    };
+}
+async function withAwsProfileOnProcessEnv(profile, run) {
+    if (profile === undefined) {
+        return run();
+    }
+    const previousProfile = process.env.AWS_PROFILE;
+    process.env.AWS_PROFILE = profile;
+    try {
+        return await run();
+    }
+    finally {
+        if (previousProfile === undefined) {
+            delete process.env.AWS_PROFILE;
+        }
+        else {
+            process.env.AWS_PROFILE = previousProfile;
+        }
+    }
+}
+function readCloudflareAccountIds(value) {
+    return (value ?? "")
+        .split(",")
+        .map((accountId) => accountId.trim())
+        .filter((accountId) => accountId.length > 0);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=sync.js.map

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

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

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

@@ -0,0 +1,181 @@
+import { Buffer } from "node:buffer";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+const THEME_USAGE = "Usage: moneysiren theme <preview|image-prompt|image-generate> [--out <png> --theme-out <json> --model <model>]";
+const DEFAULT_IMAGE_MODEL = "gpt-image-1.5";
+const DEFAULT_IMAGE_OUTPUT = ".moneysiren/themes/cli-image-reference.png";
+const DEFAULT_THEME_OUTPUT = ".moneysiren/themes/cli-theme.json";
+const IMAGE_PROMPT = `Create a polished Image 2 reference for the MoneySiren CLI theme.
+
+Product:
+- MoneySiren is a local-first cloud/SaaS usage, status, and expected billing dashboard for individual developers and small teams.
+- CLI surfaces should feel operational, calm, high-trust, and dense enough for repeated terminal use.
+
+Image direction:
+- Show a modern terminal window with a MoneySiren slash-command home screen, provider status rows, and small usage/risk indicators.
+- Use a restrained professional palette with teal as the brand accent, graphite text, warm amber warnings, and clear green success states.
+- Avoid marketing hero art, decorative blobs, oversized typography, and purple/blue gradient dominance.
+- Make spacing comfortable enough that controls do not touch, overlap, or wrap awkwardly.
+
+Return a visual reference plus this theme JSON shape:
+{
+  "version": 1,
+  "source": "image2-dashboard",
+  "ansi": {
+    "brand": "1;38;5;30",
+    "heading": "1;38;5;231",
+    "command": "38;5;35",
+    "muted": "38;5;244",
+    "warning": "38;5;214"
+  }
+}
+
+Apply the JSON locally with MONEYSIREN_CLI_THEME_FILE=<path-to-json>.`;
+export async function runThemeCommand(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === undefined) {
+        context.stderr(THEME_USAGE);
+        return 1;
+    }
+    if (subcommand === "preview") {
+        if (rest.length > 0) {
+            context.stderr(THEME_USAGE);
+            return 1;
+        }
+        context.stdout(renderThemePreview(context));
+        return 0;
+    }
+    if (subcommand === "image-prompt") {
+        if (rest.length > 0) {
+            context.stderr(THEME_USAGE);
+            return 1;
+        }
+        context.stdout(IMAGE_PROMPT);
+        return 0;
+    }
+    if (subcommand === "image-generate") {
+        return runImageGenerateCommand(rest, context);
+    }
+    context.stderr(THEME_USAGE);
+    return 1;
+}
+function renderThemePreview(context) {
+    const { theme } = context;
+    return [
+        `${theme.brand("MoneySiren")} CLI theme`,
+        `Source: ${theme.source}`,
+        "",
+        `${theme.heading("Heading")}  ${theme.command("/sync openai")}  ${theme.muted("muted metadata")}  ${theme.warning("warning")}`,
+        "",
+        "Set MONEYSIREN_CLI_THEME=image2-dashboard for the bundled image-reference palette.",
+        "Set MONEYSIREN_CLI_THEME_FILE=<json> to apply a palette extracted from an image reference.",
+    ].join("\n");
+}
+async function runImageGenerateCommand(args, context) {
+    const options = parseImageGenerateOptions(args, context.env);
+    const apiKey = context.env.OPENAI_API_KEY?.trim();
+    if (apiKey === undefined || apiKey.length === 0) {
+        context.stderr("OpenAI image generation requires OPENAI_API_KEY. The key is only read from env and is not persisted.");
+        return 1;
+    }
+    const response = await context.fetch("https://api.openai.com/v1/images/generations", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${apiKey}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            model: options.model,
+            prompt: IMAGE_PROMPT,
+            n: 1,
+            size: "1536x1024",
+            quality: "low",
+        }),
+    });
+    if (!response.ok) {
+        context.stderr(`OpenAI image generation failed with status ${response.status}.`);
+        return 1;
+    }
+    const payload = await response.json();
+    const imageBase64 = payload.data?.[0]?.b64_json;
+    if (typeof imageBase64 !== "string" || imageBase64.trim().length === 0) {
+        context.stderr("OpenAI image generation response did not include image data.");
+        return 1;
+    }
+    const imagePath = resolveCliPath(context.cwd, options.out);
+    const themePath = resolveCliPath(context.cwd, options.themeOut);
+    await writeLocalFile(imagePath, Buffer.from(imageBase64, "base64"));
+    await writeLocalFile(themePath, Buffer.from(JSON.stringify(themeFileFor(options.model), null, 2), "utf8"));
+    context.stdout("Generated MoneySiren CLI image theme reference.");
+    context.stdout(`Image: ${options.out}`);
+    context.stdout(`Theme: ${options.themeOut}`);
+    context.stdout(`Apply: MONEYSIREN_CLI_THEME_FILE=${options.themeOut} moneysiren theme preview`);
+    return 0;
+}
+function parseImageGenerateOptions(args, env) {
+    let out = DEFAULT_IMAGE_OUTPUT;
+    let themeOut = DEFAULT_THEME_OUTPUT;
+    let model = env.MONEYSIREN_IMAGE_MODEL?.trim() || DEFAULT_IMAGE_MODEL;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const value = args[index + 1];
+        if (arg === "--out" && value !== undefined) {
+            out = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--theme-out" && value !== undefined) {
+            themeOut = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--model" && value !== undefined) {
+            model = value;
+            index += 1;
+            continue;
+        }
+        throw new Error(THEME_USAGE);
+    }
+    return {
+        out: requireNonBlankPath(out, "--out"),
+        themeOut: requireNonBlankPath(themeOut, "--theme-out"),
+        model: requireSafeModelName(model),
+    };
+}
+function themeFileFor(model) {
+    return {
+        version: 1,
+        source: `image-generation:${model}`,
+        ansi: {
+            brand: "1;38;5;30",
+            heading: "1;38;5;231",
+            command: "38;5;35",
+            muted: "38;5;244",
+            warning: "38;5;214",
+        },
+    };
+}
+async function writeLocalFile(path, content) {
+    await mkdir(dirname(path), {
+        recursive: true,
+    });
+    await writeFile(path, content);
+}
+function resolveCliPath(cwd, path) {
+    return isAbsolute(path) ? path : join(cwd, path);
+}
+function requireNonBlankPath(value, label) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must not be blank.`);
+    }
+    return trimmed;
+}
+function requireSafeModelName(value) {
+    const trimmed = value.trim();
+    if (!/^[A-Za-z0-9._-]{1,80}$/.test(trimmed)) {
+        throw new Error("Image model name is invalid.");
+    }
+    return trimmed;
+}
+//# sourceMappingURL=theme.js.map

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

@@ -0,0 +1,54 @@
+import type { CliExecutionContext } from "./cli.js";
+export interface StartWebRuntimeOptions {
+    openBrowser: boolean;
+    port?: number;
+}
+export interface StartHudOptions {
+    port?: number;
+}
+export interface DesktopRuntimeStatus {
+    statePath: string;
+    web: DesktopProcessStatus;
+    hud: DesktopProcessStatus;
+}
+export interface DesktopProcessStatus {
+    target: "web" | "hud";
+    status: "running" | "not-running" | "not-managed" | "stale";
+    pid?: number;
+    detail: string;
+}
+export interface StopDesktopRuntimeOptions {
+    hud: boolean;
+    web: boolean;
+}
+export interface StopDesktopRuntimeResult {
+    target: "web" | "hud";
+    status: "stopped" | "not-running" | "not-managed" | "stale" | "failed";
+    pid?: number;
+    detail: string;
+}
+export type DesktopRuntimeResult = {
+    status: "running" | "started";
+    dashboardUrl: string;
+    pid?: number;
+    notes: readonly string[];
+} | DesktopRuntimeUnavailableResult;
+export type DesktopShellResult = {
+    status: "opened" | "started";
+    executablePath: string;
+    pid?: number;
+    notes: readonly string[];
+} | DesktopRuntimeUnavailableResult;
+export interface DesktopRuntimeUnavailableResult {
+    status: "unavailable";
+    reason: string;
+    guidance: readonly string[];
+}
+export interface CliDesktopRuntimeAdapter {
+    startWebRuntime(options: StartWebRuntimeOptions): Promise<DesktopRuntimeResult>;
+    startHud(options: StartHudOptions): Promise<DesktopShellResult>;
+    status(): Promise<DesktopRuntimeStatus>;
+    stop(options: StopDesktopRuntimeOptions): Promise<readonly StopDesktopRuntimeResult[]>;
+}
+export declare function createFallbackDesktopRuntimeAdapter(context: CliExecutionContext): CliDesktopRuntimeAdapter;
+//# sourceMappingURL=desktop-runtime.d.ts.map