@moneysiren/cli 0.1.0-alpha.6 → 0.1.0-alpha.7

package/README.md

@@ -67,7 +67,7 @@ Install the generated tarball into a temporary project:
 mkdir -p /tmp/moneysiren-alpha-review
 cd /tmp/moneysiren-alpha-review
 npm init -y
-npm install /path/to/moneysiren-cli-0.1.0-alpha.6.tgz
+npm install /path/to/moneysiren-cli-0.1.0-alpha.7.tgz
 npm exec moneysiren
 npm exec moneysiren -- --version
 npm exec moneysiren -- /version
@@ -83,7 +83,7 @@ PowerShell equivalent for the temporary project:
 New-Item -ItemType Directory -Force -Path $env:TEMP\moneysiren-alpha-review
 Set-Location $env:TEMP\moneysiren-alpha-review
 npm init -y
-npm install C:\path\to\moneysiren-cli-0.1.0-alpha.6.tgz
+npm install C:\path\to\moneysiren-cli-0.1.0-alpha.7.tgz
 npm exec moneysiren
 npm exec moneysiren -- --version
 npm exec moneysiren -- modes

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

@@ -5,7 +5,7 @@ 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, runServeCommand, runStartCommand } from "./commands/runtime.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";
@@ -134,6 +134,15 @@ async function dispatchCommand(args, 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);
     }

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

@@ -29,6 +29,7 @@ export async function runModesCommand(args, context) {
     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("");
@@ -36,10 +37,12 @@ export async function runModesCommand(args, context) {
     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 desktop status");
+    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;
 }

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

@@ -1,6 +1,9 @@
 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>;

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

@@ -1,8 +1,12 @@
 import { createFallbackDesktopRuntimeAdapter, } from "../desktop-runtime.js";
 import { createFallbackLocalRuntimeAdapter, } from "../runtime-adapter.js";
+import { removeRuntimeLock } from "../../../../packages/runtime/src/index.js";
 const SERVE_USAGE = "Usage: moneysiren serve [--port <port>]";
 const START_USAGE = "Usage: msiren start [--port <port>] [--open|--no-open] [--hud]";
 const HUD_USAGE = "Usage: msiren hud [--port <port>]";
+const STATUS_USAGE = "Usage: msiren status";
+const STOP_USAGE = "Usage: msiren stop [--web|--hud|--api|--all]";
+const RESTART_USAGE = "Usage: msiren restart [--port <port>] [--open|--no-open] [--hud]";
 const OPEN_USAGE = "Usage: moneysiren open";
 const DESKTOP_USAGE = "Usage: moneysiren desktop status";
 export async function runServeCommand(args, context) {
@@ -21,6 +25,31 @@ export async function runServeCommand(args, context) {
     });
     return writeStartRuntimeResult(context, result, "MoneySiren local runtime");
 }
+export async function runStatusCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(STATUS_USAGE);
+        return 0;
+    }
+    if (args.length > 0) {
+        context.stderr(STATUS_USAGE);
+        return 1;
+    }
+    const desktop = await desktopRuntimeAdapter(context).status();
+    const api = await runtimeAdapter(context).findRuntime();
+    context.stdout("MoneySiren status");
+    writeDesktopProcessStatus(context, "Web runtime", desktop.web);
+    writeDesktopProcessStatus(context, "HUD", desktop.hud);
+    context.stdout(`Desktop state: ${desktop.statePath}`);
+    if (api === null) {
+        context.stdout("Local API runtime: not running");
+        return 0;
+    }
+    const healthy = await runtimeAdapter(context).assertRuntimeHealthy(api);
+    context.stdout(`Local API runtime: ${healthy ? "healthy" : "unhealthy"}`);
+    context.stdout(`  PID: ${api.pid}`);
+    context.stdout(`  URL: ${api.baseUrl}`);
+    return healthy ? 0 : 1;
+}
 export async function runStartCommand(args, context) {
     if (args.includes("--help") || args.includes("-h")) {
         context.stdout(START_USAGE);
@@ -53,6 +82,54 @@ export async function runStartCommand(args, context) {
     });
     return writeDesktopShellResult(context, hud, "MoneySiren HUD");
 }
+export async function runStopCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(STOP_USAGE);
+        return 0;
+    }
+    const selection = parseStopArgs(args);
+    if (selection === undefined) {
+        context.stderr(STOP_USAGE);
+        return 1;
+    }
+    context.stdout("MoneySiren stop");
+    const desktopResults = await desktopRuntimeAdapter(context).stop({
+        hud: selection.hud,
+        web: selection.web,
+    });
+    for (const result of desktopResults) {
+        writeStopDesktopRuntimeResult(context, result);
+    }
+    let exitCode = desktopResults.some((result) => result.status === "failed") ? 1 : 0;
+    if (selection.api) {
+        const apiResult = await stopLocalApiRuntime(context);
+        context.stdout(`Local API runtime: ${apiResult.status}`);
+        context.stdout(`  ${apiResult.detail}`);
+        if (apiResult.pid !== undefined) {
+            context.stdout(`  PID: ${apiResult.pid}`);
+        }
+        if (apiResult.status === "failed") {
+            exitCode = 1;
+        }
+    }
+    return exitCode;
+}
+export async function runRestartCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(RESTART_USAGE);
+        return 0;
+    }
+    const parsed = parseStartArgs(args);
+    if (parsed === undefined) {
+        context.stderr(RESTART_USAGE);
+        return 1;
+    }
+    const stopExitCode = await runStopCommand(["--web", "--hud"], context);
+    if (stopExitCode !== 0) {
+        return stopExitCode;
+    }
+    return runStartCommand(args, context);
+}
 export async function runHudCommand(args, context) {
     if (args.includes("--help") || args.includes("-h")) {
         context.stdout(HUD_USAGE);
@@ -77,6 +154,54 @@ export async function runHudCommand(args, context) {
     });
     return writeDesktopShellResult(context, hud, "MoneySiren HUD");
 }
+async function stopLocalApiRuntime(context) {
+    const adapter = runtimeAdapter(context);
+    const runtime = await adapter.findRuntime();
+    if (runtime === null) {
+        return {
+            status: "not-running",
+            detail: "No managed local API runtime lock was found.",
+        };
+    }
+    try {
+        process.kill(runtime.pid, "SIGTERM");
+        await waitForProcessExit(runtime.pid, 3_000);
+        if (isProcessAlive(runtime.pid)) {
+            return {
+                status: "failed",
+                detail: "Local API runtime did not exit after SIGTERM.",
+                pid: runtime.pid,
+            };
+        }
+        await removeRuntimeLock({
+            cwd: context.cwd,
+            env: context.env,
+        });
+        return {
+            status: "stopped",
+            detail: "Managed local API runtime stopped.",
+            pid: runtime.pid,
+        };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ESRCH") {
+            await removeRuntimeLock({
+                cwd: context.cwd,
+                env: context.env,
+            });
+            return {
+                status: "stale",
+                detail: "Removed stale local API runtime lock.",
+                pid: runtime.pid,
+            };
+        }
+        return {
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+            pid: runtime.pid,
+        };
+    }
+}
 export async function runOpenCommand(args, context) {
     if (args.includes("--help") || args.includes("-h")) {
         context.stdout(OPEN_USAGE);
@@ -204,6 +329,21 @@ function writeDesktopShellResult(context, result, heading) {
     }
     return 1;
 }
+function writeDesktopProcessStatus(context, label, status) {
+    context.stdout(`${label}: ${status.status}`);
+    if (status.pid !== undefined) {
+        context.stdout(`  PID: ${status.pid}`);
+    }
+    context.stdout(`  ${status.detail}`);
+}
+function writeStopDesktopRuntimeResult(context, result) {
+    const label = result.target === "web" ? "Web runtime" : "HUD";
+    context.stdout(`${label}: ${result.status}`);
+    context.stdout(`  ${result.detail}`);
+    if (result.pid !== undefined) {
+        context.stdout(`  PID: ${result.pid}`);
+    }
+}
 function parseServeArgs(args) {
     let port;
     for (let index = 0; index < args.length; index += 1) {
@@ -228,6 +368,41 @@ function parseServeArgs(args) {
     }
     return Number.isSafeInteger(port) && port > 0 && port <= 65_535 ? { port } : undefined;
 }
+function parseStopArgs(args) {
+    let web = false;
+    let hud = false;
+    let api = false;
+    let all = false;
+    for (const arg of args) {
+        if (arg === "--web") {
+            web = true;
+        }
+        else if (arg === "--hud") {
+            hud = true;
+        }
+        else if (arg === "--api") {
+            api = true;
+        }
+        else if (arg === "--all") {
+            all = true;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (all || (!web && !hud && !api)) {
+        return {
+            api: true,
+            hud: true,
+            web: true,
+        };
+    }
+    return {
+        api,
+        hud,
+        web,
+    };
+}
 function parseStartArgs(args) {
     let launchHud = false;
     let openBrowser = true;
@@ -297,4 +472,28 @@ function parseHudArgs(args) {
 function parsePort(value) {
     return Number.parseInt(value, 10);
 }
+function isProcessAlive(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isNodeError(error) && error.code === "EPERM";
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        await new Promise((resolveTimeout) => setTimeout(resolveTimeout, 100));
+    }
+}
+function isNodeError(value) {
+    return value instanceof Error && "code" in value;
+}
 //# sourceMappingURL=runtime.js.map

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

@@ -6,6 +6,27 @@ export interface StartWebRuntimeOptions {
 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;
@@ -26,6 +47,8 @@ export interface DesktopRuntimeUnavailableResult {
 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

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

@@ -1,12 +1,15 @@
 import { execFile, spawn } from "node:child_process";
 import { constants } from "node:fs";
-import { access, mkdir, readFile, readdir, stat } from "node:fs/promises";
-import { basename, dirname, extname, join, resolve } from "node:path";
+import { access, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, posix, resolve, win32 } from "node:path";
 import { promisify } from "node:util";
 import { resolveReleaseInstallDir } from "./release-installer.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_WEB_PORT = 3000;
 const DEFAULT_HEALTH_TIMEOUT_MS = 30_000;
+const DESKTOP_STATE_ENV_KEY = "MONEYSIREN_DESKTOP_RUNTIME_STATE_PATH";
+const STOP_TIMEOUT_MS = 3_000;
 export function createFallbackDesktopRuntimeAdapter(context) {
     return {
         async startWebRuntime(options) {
@@ -14,9 +17,11 @@ export function createFallbackDesktopRuntimeAdapter(context) {
             const dashboardUrl = `http://127.0.0.1:${port}/ko/dashboard/overview`;
             const healthUrl = `http://127.0.0.1:${port}/api/local/health`;
             if (await isWebRuntimeHealthy(healthUrl, context.fetch)) {
+                const status = await readDesktopRuntimeStatus(context);
                 return {
                     status: "running",
                     dashboardUrl,
+                    ...(status.web.status === "running" && status.web.pid !== undefined ? { pid: status.web.pid } : {}),
                     notes: ["Existing local dashboard runtime is healthy."],
                 };
             }
@@ -47,6 +52,17 @@ export function createFallbackDesktopRuntimeAdapter(context) {
                     ],
                 };
             }
+            if (child.pid !== undefined) {
+                await updateDesktopRuntimeState(context, (state) => ({
+                    ...state,
+                    web: {
+                        pid: child.pid,
+                        port,
+                        dashboardUrl,
+                        startedAt: new Date().toISOString(),
+                    },
+                }));
+            }
             return {
                 status: "started",
                 dashboardUrl,
@@ -55,6 +71,15 @@ export function createFallbackDesktopRuntimeAdapter(context) {
             };
         },
         async startHud(options) {
+            const status = await readDesktopRuntimeStatus(context);
+            if (status.hud.status === "running" && status.hud.pid !== undefined) {
+                return {
+                    status: "opened",
+                    executablePath: status.hud.detail,
+                    pid: status.hud.pid,
+                    notes: ["Existing desktop HUD shell is already running."],
+                };
+            }
             const executable = await resolveDesktopExecutable(context);
             if (isUnavailable(executable)) {
                 return executable;
@@ -72,6 +97,16 @@ export function createFallbackDesktopRuntimeAdapter(context) {
                 windowsHide: true,
             });
             child.unref();
+            if (child.pid !== undefined) {
+                await updateDesktopRuntimeState(context, (state) => ({
+                    ...state,
+                    hud: {
+                        executablePath: executable.executablePath,
+                        pid: child.pid,
+                        startedAt: new Date().toISOString(),
+                    },
+                }));
+            }
             return {
                 status: "started",
                 executablePath: executable.executablePath,
@@ -79,8 +114,156 @@ export function createFallbackDesktopRuntimeAdapter(context) {
                 notes: ["Desktop HUD shell launched with MONEYSIREN_DESKTOP_MODE=hud."],
             };
         },
+        async status() {
+            return readDesktopRuntimeStatus(context);
+        },
+        async stop(options) {
+            return stopDesktopRuntime(context, options);
+        },
+    };
+}
+async function readDesktopRuntimeStatus(context) {
+    const statePath = resolveDesktopRuntimeStatePath(context);
+    const state = await readDesktopRuntimeState(context);
+    const port = configuredPort(context.env);
+    const webHealthUrl = `http://127.0.0.1:${port}/api/local/health`;
+    const web = await processStatus({
+        context,
+        detail: state?.web?.dashboardUrl ?? `http://127.0.0.1:${port}`,
+        healthUrl: webHealthUrl,
+        process: state?.web,
+        target: "web",
+    });
+    const hud = await processStatus({
+        context,
+        detail: state?.hud?.executablePath ?? "No managed HUD process recorded.",
+        process: state?.hud,
+        target: "hud",
+    });
+    return {
+        statePath,
+        web,
+        hud,
+    };
+}
+async function stopDesktopRuntime(context, options) {
+    const state = await readDesktopRuntimeState(context);
+    const results = [];
+    let nextState = state ?? emptyDesktopRuntimeState();
+    if (options.web) {
+        const result = state?.web === undefined && await isWebRuntimeHealthy(`http://127.0.0.1:${configuredPort(context.env)}/api/local/health`, context.fetch)
+            ? {
+                target: "web",
+                status: "not-managed",
+                detail: "A local dashboard runtime is reachable, but no MoneySiren CLI PID is recorded. It was not stopped.",
+            }
+            : await stopManagedProcess("web", state?.web);
+        results.push(result);
+        if (result.status !== "failed") {
+            const { web: _web, ...rest } = nextState;
+            nextState = rest;
+        }
+    }
+    if (options.hud) {
+        const result = await stopManagedProcess("hud", state?.hud);
+        results.push(result);
+        if (result.status !== "failed") {
+            const { hud: _hud, ...rest } = nextState;
+            nextState = rest;
+        }
+    }
+    await writeOrRemoveDesktopRuntimeState(context, nextState);
+    return results;
+}
+async function processStatus(input) {
+    if (input.process === undefined) {
+        if (input.target === "web" && input.healthUrl !== undefined && await isWebRuntimeHealthy(input.healthUrl, input.context.fetch)) {
+            return {
+                target: input.target,
+                status: "not-managed",
+                detail: `${input.detail} is reachable, but no MoneySiren CLI PID is recorded.`,
+            };
+        }
+        return {
+            target: input.target,
+            status: "not-running",
+            detail: input.detail,
+        };
+    }
+    if (!isProcessAlive(input.process.pid)) {
+        return {
+            target: input.target,
+            status: "stale",
+            pid: input.process.pid,
+            detail: input.detail,
+        };
+    }
+    return {
+        target: input.target,
+        status: "running",
+        pid: input.process.pid,
+        detail: input.detail,
     };
 }
+async function stopManagedProcess(target, processRecord) {
+    if (processRecord === undefined) {
+        return {
+            target,
+            status: "not-running",
+            detail: `No managed ${target} process is recorded.`,
+        };
+    }
+    if (!isProcessAlive(processRecord.pid)) {
+        return {
+            target,
+            status: "stale",
+            pid: processRecord.pid,
+            detail: `Removed stale ${target} process record.`,
+        };
+    }
+    if (processRecord.pid === process.pid) {
+        return {
+            target,
+            status: "failed",
+            pid: processRecord.pid,
+            detail: "Refusing to stop the current CLI process.",
+        };
+    }
+    try {
+        process.kill(processRecord.pid, "SIGTERM");
+        await waitForProcessExit(processRecord.pid, STOP_TIMEOUT_MS);
+        if (isProcessAlive(processRecord.pid)) {
+            return {
+                target,
+                status: "failed",
+                pid: processRecord.pid,
+                detail: `${target} process did not exit after SIGTERM.`,
+            };
+        }
+        return {
+            target,
+            status: "stopped",
+            pid: processRecord.pid,
+            detail: `${target} process stopped.`,
+        };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ESRCH") {
+            return {
+                target,
+                status: "stale",
+                pid: processRecord.pid,
+                detail: `Removed stale ${target} process record.`,
+            };
+        }
+        return {
+            target,
+            status: "failed",
+            pid: processRecord.pid,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 async function resolveWebRuntimeStartScript(context) {
     const configured = trimToNull(context.env.MONEYSIREN_WEB_RUNTIME_DIR);
     if (configured !== null) {
@@ -424,6 +607,99 @@ async function pathExists(path) {
         return false;
     }
 }
+async function readDesktopRuntimeState(context) {
+    try {
+        const parsed = JSON.parse(await readFile(resolveDesktopRuntimeStatePath(context), "utf8"));
+        return parseDesktopRuntimeState(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+async function updateDesktopRuntimeState(context, update) {
+    await writeOrRemoveDesktopRuntimeState(context, update(await readDesktopRuntimeState(context) ?? emptyDesktopRuntimeState()));
+}
+async function writeOrRemoveDesktopRuntimeState(context, state) {
+    const statePath = resolveDesktopRuntimeStatePath(context);
+    if (state.web === undefined && state.hud === undefined) {
+        await rm(statePath, { force: true });
+        return;
+    }
+    const nextState = {
+        ...state,
+        updatedAt: new Date().toISOString(),
+    };
+    await mkdir(dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(nextState, null, 2)}\n`, "utf8");
+}
+function resolveDesktopRuntimeStatePath(context) {
+    const configured = trimToNull(context.env[DESKTOP_STATE_ENV_KEY]);
+    if (configured !== null) {
+        return resolve(context.cwd, configured);
+    }
+    if (process.platform === "win32") {
+        return win32.join(trimToNull(context.env.APPDATA) ?? win32.join(resolveHomeDirectory(context.env), "AppData", "Roaming"), "MoneySiren", "desktop-runtime.json");
+    }
+    if (process.platform === "darwin") {
+        return posix.join(resolveHomeDirectory(context.env), "Library", "Application Support", "MoneySiren", "desktop-runtime.json");
+    }
+    return posix.join(trimToNull(context.env.XDG_STATE_HOME) ?? posix.join(resolveHomeDirectory(context.env), ".local", "state"), "moneysiren", "desktop-runtime.json");
+}
+function parseDesktopRuntimeState(value) {
+    if (!isRecord(value) || value.version !== 1 || typeof value.updatedAt !== "string") {
+        return null;
+    }
+    const web = parseManagedDesktopProcess(value.web);
+    const hud = parseManagedDesktopProcess(value.hud);
+    return {
+        version: 1,
+        updatedAt: value.updatedAt,
+        ...(web === undefined ? {} : { web }),
+        ...(hud === undefined ? {} : { hud }),
+    };
+}
+function parseManagedDesktopProcess(value) {
+    if (!isRecord(value) || typeof value.pid !== "number" || typeof value.startedAt !== "string" || !Number.isSafeInteger(value.pid)) {
+        return undefined;
+    }
+    return {
+        pid: value.pid,
+        startedAt: value.startedAt,
+        ...(typeof value.port === "number" && Number.isSafeInteger(value.port) ? { port: value.port } : {}),
+        ...(typeof value.dashboardUrl === "string" ? { dashboardUrl: value.dashboardUrl } : {}),
+        ...(typeof value.executablePath === "string" ? { executablePath: value.executablePath } : {}),
+    };
+}
+function emptyDesktopRuntimeState() {
+    return {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+    };
+}
+function isProcessAlive(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isNodeError(error) && error.code === "EPERM";
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        await new Promise((resolveTimeout) => setTimeout(resolveTimeout, 100));
+    }
+}
+function resolveHomeDirectory(env) {
+    return trimToNull(env.HOME) ?? trimToNull(env.USERPROFILE) ?? homedir();
+}
 function configuredPort(env) {
     const parsed = Number.parseInt(env.PORT ?? "", 10);
     return Number.isSafeInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : DEFAULT_WEB_PORT;
@@ -438,4 +714,7 @@ function errorMessage(error) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isNodeError(value) {
+    return value instanceof Error && "code" in value;
+}
 //# sourceMappingURL=desktop-runtime.js.map

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

@@ -12,6 +12,8 @@ export function renderHomeScreen(input) {
         `  ${theme.command("/modes")}                Show the CLI, web, and desktop modes`,
         `  ${theme.command("/start")}                Start the installed dashboard runtime`,
         `  ${theme.command("/hud")}                  Start the installed runtime and open HUD`,
+        `  ${theme.command("/status")}               Show managed web, HUD, and local API runtime status`,
+        `  ${theme.command("/stop")}                 Stop managed web, HUD, and local API runtimes`,
         `  ${theme.command("/init")}                 Create local SQLite storage`,
         `  ${theme.command("/dashboard")}            Check the local dashboard API`,
         `  ${theme.command("/dashboard check")}      Same as /dashboard`,
@@ -31,6 +33,8 @@ export function renderHomeScreen(input) {
         theme.heading("Classic CLI"),
         "  msiren start",
         "  msiren hud",
+        "  msiren status",
+        "  msiren stop",
         "  msiren install --all",
         "",
         theme.heading("Full command"),
@@ -40,6 +44,8 @@ export function renderHomeScreen(input) {
         "  moneysiren modes",
         "  moneysiren init",
         "  moneysiren serve [--port <port>]",
+        "  moneysiren stop [--web|--hud|--api|--all]",
+        "  moneysiren restart [--port <port>] [--open|--no-open] [--hud]",
         "  moneysiren open",
         "  moneysiren sync --provider mock",
         "  moneysiren summary --json",
@@ -76,6 +82,9 @@ Usage:
   moneysiren modes
   moneysiren start [--port <port>] [--open|--no-open] [--hud]
   moneysiren hud [--port <port>]
+  moneysiren status
+  moneysiren stop [--web|--hud|--api|--all]
+  moneysiren restart [--port <port>] [--open|--no-open] [--hud]
   moneysiren dashboard check [--url <local-dashboard-url>]
   moneysiren serve [--port <port>]
   moneysiren open
@@ -97,6 +106,8 @@ Slash commands:
   moneysiren /modes
   moneysiren /start
   moneysiren /hud
+  moneysiren /status
+  moneysiren /stop [--web|--hud|--api|--all]
   moneysiren /init
   moneysiren /dashboard
   moneysiren /dashboard check

package/dist/apps/cli/src/release-installer.d.ts

@@ -1,6 +1,6 @@
 import type { InstallSurface } from "./install-profile.js";
 export declare const DEFAULT_RELEASE_REPOSITORY = "ztwz11/moneysiren";
-export declare const DEFAULT_RELEASE_TAG = "v0.1.0-alpha.6";
+export declare const DEFAULT_RELEASE_TAG = "v0.1.0-alpha.7";
 export interface ReleaseInstallOptions {
     env?: Record<string, string | undefined>;
     fetchImpl: typeof fetch;

package/dist/apps/cli/src/release-installer.js

@@ -7,7 +7,7 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 export const DEFAULT_RELEASE_REPOSITORY = "ztwz11/moneysiren";
 // Keep the source-free installer pinned to the latest published desktop/web release tag.
-export const DEFAULT_RELEASE_TAG = "v0.1.0-alpha.6";
+export const DEFAULT_RELEASE_TAG = "v0.1.0-alpha.7";
 const RELEASE_REPOSITORY_ENV_KEY = "MONEYSIREN_RELEASE_REPOSITORY";
 const RELEASE_TAG_ENV_KEY = "MONEYSIREN_RELEASE_TAG";
 const RELEASE_INSTALL_DIR_ENV_KEY = "MONEYSIREN_RELEASE_INSTALL_DIR";

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

@@ -46,6 +46,21 @@ export function resolveSlashCommand(args) {
             args: ["hud", ...rest],
         };
     }
+    if (command === "/status") {
+        return noExtraArgs(command, rest, ["status"]);
+    }
+    if (command === "/stop") {
+        return {
+            kind: "dispatch",
+            args: ["stop", ...rest],
+        };
+    }
+    if (command === "/restart") {
+        return {
+            kind: "dispatch",
+            args: ["restart", ...rest],
+        };
+    }
     if (command === "/init") {
         return noExtraArgs(command, rest, ["init"]);
     }

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

@@ -1,2 +1,2 @@
-export declare const CLI_VERSION = "0.1.0-alpha.6";
+export declare const CLI_VERSION = "0.1.0-alpha.7";
 //# sourceMappingURL=version.d.ts.map

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

@@ -1,2 +1,2 @@
-export const CLI_VERSION = "0.1.0-alpha.6";
+export const CLI_VERSION = "0.1.0-alpha.7";
 //# sourceMappingURL=version.js.map

package/dist/packages/local-api/src/server.js

@@ -3,7 +3,7 @@ import { parseNotificationPreferences, readNotificationDigest, readNotificationP
 import { assertLoopbackHost, isLoopbackHost, removeRuntimeLock, writeRuntimeLock, } from "../../runtime/src/index.js";
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 47831;
-const DEFAULT_VERSION = "0.1.0-alpha.6";
+const DEFAULT_VERSION = "0.1.0-alpha.7";
 export async function startLocalApiServer(options = {}) {
     const host = options.host ?? DEFAULT_HOST;
     const requestedPort = options.port ?? DEFAULT_PORT;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneysiren/cli",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Local-first cloud/SaaS usage, status, and expected billing CLI for MoneySiren.",
   "private": false,
   "license": "MIT",