@moneysiren/app 0.1.0-alpha.9

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

@@ -0,0 +1,244 @@
+import { DEFAULT_INSTALL_SURFACES, INSTALL_SURFACES, isInstallSurface, readInstallProfileFile, resolveInstallProfilePath, writeInstallProfileFile, } from "../install-profile.js";
+import { formatInstallSelectionLine, installSelectionHelp, parseInstallSurfaceSelection, promptForInstallSurfaces, } from "../install-selector.js";
+import { DEFAULT_RELEASE_REPOSITORY, DEFAULT_RELEASE_TAG, installReleaseAssets, } from "../release-installer.js";
+const INSTALL_USAGE = [
+    "Usage: moneysiren install [--status|--all|--cli|--web|--hud|--no-cli|--no-web|--no-hud] [--profile-only] [--tag <tag>] [--repo <owner/name>] [--dir <path>]",
+    "",
+    "Components:",
+    installSelectionHelp(),
+    "",
+    "Default: all components selected (recommended).",
+    `Release default: ${DEFAULT_RELEASE_REPOSITORY}@${DEFAULT_RELEASE_TAG}.`,
+].join("\n");
+export async function runInstallCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(INSTALL_USAGE);
+        return 0;
+    }
+    if (args.length === 1 && args[0] === "--status") {
+        return writeInstallStatus(context);
+    }
+    const parsed = parseInstallArgs(args);
+    if (parsed === null) {
+        context.stderr(INSTALL_USAGE);
+        return 1;
+    }
+    const selectedSurfaces = parsed.selectedSurfaces ?? await selectedSurfacesFromPromptOrDefault(context);
+    const releaseResult = await installReleaseAssetsForSelectionSafely({
+        context,
+        parsed,
+        selectedSurfaces,
+    });
+    if (releaseResult === "failed") {
+        return 1;
+    }
+    const profile = await writeInstallProfileFile({
+        selectedSurfaces,
+        source: "cli",
+        recommendedDefault: isDefaultSelection(selectedSurfaces),
+    }, {
+        env: context.env,
+        now: context.now,
+    });
+    context.stdout("MoneySiren install profile updated.");
+    context.stdout(formatInstallSelectionLine(profile.selectedSurfaces));
+    writeReleaseInstallResult(context, releaseResult);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function writeInstallStatus(context) {
+    const profile = await readInstallProfileFile({
+        env: context.env,
+    });
+    const selectedSurfaces = profile?.selectedSurfaces ?? DEFAULT_INSTALL_SURFACES;
+    context.stdout("MoneySiren install profile");
+    context.stdout(`Status: ${profile === null ? "not configured; using recommended default" : "configured"}`);
+    context.stdout(formatInstallSelectionLine(selectedSurfaces));
+    context.stdout(`Recommended default: ${isDefaultSelection(selectedSurfaces) ? "yes" : "no"}`);
+    context.stdout(`Profile path: ${resolveInstallProfilePath({ env: context.env })}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function selectedSurfacesFromPromptOrDefault(context) {
+    if (!context.interactive || context.stdin === undefined || context.output === undefined) {
+        return DEFAULT_INSTALL_SURFACES;
+    }
+    return promptForInstallSurfaces({
+        stdin: context.stdin,
+        output: context.output,
+    });
+}
+function parseInstallArgs(args) {
+    if (args.length === 0) {
+        return {
+            profileOnly: false,
+        };
+    }
+    if (args.length === 1) {
+        const selected = parseInstallSurfaceSelection(args[0] ?? "");
+        if (selected !== null) {
+            return {
+                profileOnly: false,
+                selectedSurfaces: selected,
+            };
+        }
+    }
+    let explicitIncludes = false;
+    let installDir;
+    let profileOnly = false;
+    let releaseRepository;
+    let releaseTag;
+    const selected = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined) {
+            return null;
+        }
+        if (arg === "--profile-only") {
+            profileOnly = true;
+            continue;
+        }
+        if (arg === "--tag" || arg === "--repo" || arg === "--dir") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return null;
+            }
+            if (arg === "--tag") {
+                releaseTag = value;
+            }
+            else if (arg === "--repo") {
+                releaseRepository = value;
+            }
+            else {
+                installDir = value;
+            }
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--tag=")) {
+            releaseTag = arg.slice("--tag=".length);
+            continue;
+        }
+        if (arg.startsWith("--repo=")) {
+            releaseRepository = arg.slice("--repo=".length);
+            continue;
+        }
+        if (arg.startsWith("--dir=")) {
+            installDir = arg.slice("--dir=".length);
+            continue;
+        }
+        if (arg === "--all") {
+            for (const surface of DEFAULT_INSTALL_SURFACES) {
+                selected.add(surface);
+            }
+            explicitIncludes = true;
+            continue;
+        }
+        if (arg.startsWith("--no-")) {
+            const surface = arg.slice("--no-".length);
+            if (!isInstallSurface(surface)) {
+                return null;
+            }
+            if (!explicitIncludes) {
+                for (const defaultSurface of DEFAULT_INSTALL_SURFACES) {
+                    selected.add(defaultSurface);
+                }
+                explicitIncludes = true;
+            }
+            selected.delete(surface);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const surface = arg.slice("--".length);
+            if (!isInstallSurface(surface)) {
+                return null;
+            }
+            selected.add(surface);
+            explicitIncludes = true;
+            continue;
+        }
+        if (!isInstallSurface(arg)) {
+            return null;
+        }
+        selected.add(arg);
+        explicitIncludes = true;
+    }
+    const normalized = INSTALL_SURFACES.filter((surface) => selected.has(surface));
+    if (normalized.length === 0 && explicitIncludes) {
+        return null;
+    }
+    return {
+        ...(installDir === undefined ? {} : { installDir }),
+        profileOnly,
+        ...(releaseRepository === undefined ? {} : { releaseRepository }),
+        ...(releaseTag === undefined ? {} : { releaseTag }),
+        ...(normalized.length === 0 ? {} : { selectedSurfaces: normalized }),
+    };
+}
+function isDefaultSelection(selectedSurfaces) {
+    return selectedSurfaces.length === INSTALL_SURFACES.length &&
+        INSTALL_SURFACES.every((surface, index) => selectedSurfaces[index] === surface);
+}
+async function installReleaseAssetsForSelection(input) {
+    if (input.parsed.profileOnly) {
+        return "profile-only";
+    }
+    if (!input.selectedSurfaces.some((surface) => surface === "web" || surface === "hud")) {
+        return "cli-only";
+    }
+    return installReleaseAssets({
+        env: input.context.env,
+        fetchImpl: input.context.fetch,
+        ...(input.parsed.installDir === undefined ? {} : { installDir: input.parsed.installDir }),
+        now: input.context.now,
+        ...(input.parsed.releaseRepository === undefined ? {} : { repository: input.parsed.releaseRepository }),
+        selectedSurfaces: input.selectedSurfaces,
+        ...(input.parsed.releaseTag === undefined ? {} : { tag: input.parsed.releaseTag }),
+    });
+}
+async function installReleaseAssetsForSelectionSafely(input) {
+    try {
+        return await installReleaseAssetsForSelection(input);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        input.context.stderr(`Release asset installation failed: ${message}`);
+        if (input.selectedSurfaces.includes("hud")) {
+            input.context.stderr("The selected HUD desktop artifact must be present, checksummed, and signed before MoneySiren will install it.");
+            input.context.stderr("For now, use `moneysiren install --web` to install only the web runtime, or retry after a signed desktop release is published.");
+        }
+        input.context.stderr("Install profile was not changed.");
+        return "failed";
+    }
+}
+function writeReleaseInstallResult(context, result) {
+    if (result === "profile-only") {
+        context.stdout("Release assets: skipped (--profile-only).");
+        return;
+    }
+    if (result === "cli-only") {
+        context.stdout("Release assets: skipped (CLI-only selection).");
+        return;
+    }
+    writeReleaseInstallSummary(context, result);
+}
+function writeReleaseInstallSummary(context, result) {
+    context.stdout(`Release: ${result.repository}@${result.tag}`);
+    context.stdout(`Release URL: ${result.releaseUrl}`);
+    context.stdout(`Install directory: ${result.installDir}`);
+    for (const asset of result.assets) {
+        context.stdout(`Downloaded ${asset.surface}: ${asset.name}`);
+        context.stdout(`  SHA256 verified: ${asset.checksumVerified ? "yes" : "checksum unavailable"}`);
+        context.stdout(`  Signature status: ${formatSignatureStatus(asset)}`);
+    }
+}
+function formatSignatureStatus(asset) {
+    if (asset.signatureVerified) {
+        return "verified";
+    }
+    if (asset.signatureStatus === "unsigned-prerelease-accepted") {
+        return "unsigned alpha accepted";
+    }
+    return "not required";
+}
+//# sourceMappingURL=install.js.map

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

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

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

@@ -0,0 +1,73 @@
+import { DEFAULT_INSTALL_SURFACES, formatInstallSurfaces, readInstallProfileFile, } from "../install-profile.js";
+const MODES_USAGE = "Usage: moneysiren modes";
+export async function runModesCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(MODES_USAGE);
+        return 0;
+    }
+    if (args.length > 0) {
+        context.stderr(MODES_USAGE);
+        return 1;
+    }
+    const profile = await readInstallProfileFile({
+        env: context.env,
+    });
+    const selectedSurfaces = profile?.selectedSurfaces ?? DEFAULT_INSTALL_SURFACES;
+    context.stdout("MoneySiren modes");
+    context.stdout(`Platform: ${platformLabel()}`);
+    context.stdout(`Install profile: ${formatInstallSurfaces(selectedSurfaces)}${profile === null ? " (recommended default)" : ""}`);
+    context.stdout("npm install: npm install -g @moneysiren/cli@alpha");
+    context.stdout("Short command: msiren");
+    context.stdout(`Runtime lock: ${runtimeLockHint()}`);
+    context.stdout("");
+    context.stdout("1. CLI automation");
+    context.stdout(`   Status: ${surfaceStatus("cli", selectedSurfaces)} from the npm CLI package`);
+    context.stdout("   Try: msiren doctor");
+    context.stdout("   Try: msiren sync --provider mock");
+    context.stdout("");
+    context.stdout("2. Local web dashboard/runtime");
+    context.stdout(`   Status: ${surfaceStatus("web", selectedSurfaces)} GitHub Release web runtime archive is installed by the CLI`);
+    context.stdout("   Install: msiren install --web");
+    context.stdout("   Try: msiren start");
+    context.stdout("   Stop: msiren stop --web");
+    context.stdout("   Try: msiren dashboard check");
+    context.stdout("   Note: msiren start runs the installed GitHub Release web runtime.");
+    context.stdout("");
+    context.stdout("3. Desktop tray/notifier");
+    context.stdout(`   Status: ${surfaceStatus("hud", selectedSurfaces)} Windows/macOS target is the thin Tauri tray shell from GitHub Releases`);
+    context.stdout("   Install: msiren install --hud");
+    context.stdout("   Try: msiren hud");
+    context.stdout("   Try: msiren status");
+    context.stdout("   Stop: msiren stop --hud");
+    context.stdout("   Try: msiren notify once --dry-run");
+    context.stdout("");
+    context.stdout("Install recommended set: msiren install --all");
+    context.stdout("Stop managed runtimes: msiren stop");
+    context.stdout("Change selection only: msiren install --profile-only");
+    return 0;
+}
+function surfaceStatus(surface, selectedSurfaces) {
+    return selectedSurfaces.includes(surface) ? "selected;" : "not selected;";
+}
+function platformLabel() {
+    if (process.platform === "darwin") {
+        return `macOS (${process.platform} ${process.arch})`;
+    }
+    if (process.platform === "win32") {
+        return `Windows (${process.platform} ${process.arch})`;
+    }
+    if (process.platform === "linux") {
+        return `Linux (${process.platform} ${process.arch})`;
+    }
+    return `${process.platform} ${process.arch}`;
+}
+function runtimeLockHint() {
+    if (process.platform === "darwin") {
+        return "~/Library/Application Support/MoneySiren/runtime.json";
+    }
+    if (process.platform === "win32") {
+        return "%APPDATA%\\MoneySiren\\runtime.json";
+    }
+    return "${XDG_CONFIG_HOME:-~/.config}/moneysiren/runtime.json";
+}
+//# sourceMappingURL=modes.js.map

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

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