@cogcoin/client 1.1.4 → 1.1.5

package/dist/cli/commands/mining-runtime.js

@@ -1,21 +1,19 @@
 import { dirname } from "node:path";
 import { DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap.js";
+import { createEmptyMiningFollowVisualizerState, MiningFollowVisualizer, } from "../../wallet/mining/visualizer.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
-import { ManagedIndexerProgressObserver, pollManagedIndexerUntilCaughtUp, } from "../managed-indexer-observer.js";
-import { buildMineStartData, buildMineStopData, } from "../mining-json.js";
-import { buildMineStartPreviewData, buildMineStopPreviewData, } from "../preview-json.js";
+import { ManagedIndexerProgressObserver, assertManagedIndexerStatusRecoverable, isManagedIndexerCaughtUp, pollManagedIndexerUntilCaughtUp, } from "../managed-indexer-observer.js";
 import { usesTtyProgress, writeLine } from "../io.js";
-import { createTerminalPrompter } from "../prompt.js";
-import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMiningControlJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
+import { writeHandledCliError } from "../output.js";
 import { formatNextStepLines, getMineStopNextSteps, } from "../workflow-hints.js";
 import { createCloseSignalWatcher, waitForCompletionOrStop } from "../signals.js";
 import { createSyncProgressReporter } from "../sync-progress.js";
 import { PASSIVE_UPDATE_CHECK_TIMEOUT_MS, applyUpdateCheckResult, compareSemver, createEmptyUpdateCheckCache, fetchLatestPublishedVersion, isUpdateCheckDisabled, loadUpdateCheckCache, persistUpdateCheckCache, shouldRefreshUpdateCheck, } from "../update-service.js";
-function createCommandPrompter(parsed, context) {
-    return parsed.outputMode !== "text"
-        ? createTerminalPrompter(context.stdin, context.stderr)
-        : context.createPrompter();
+const MANAGED_MINING_READINESS_POLL_INTERVAL_MS = 500;
+const EMPTY_MINING_VISUALIZER_STATE = createEmptyMiningFollowVisualizerState();
+function createCommandPrompter(context) {
+    return context.createPrompter();
 }
 async function ensureMiningProviderSetup(options) {
     const setupReady = await options.context.ensureBuiltInMiningSetupIfNeeded({
@@ -27,6 +25,202 @@ async function ensureMiningProviderSetup(options) {
         throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
     }
 }
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+function mapManagedIndexerStateToMiningState(state) {
+    switch (state) {
+        case "starting":
+        case "catching-up":
+        case "reorging":
+        case "synced":
+        case "failed":
+        case "schema-mismatch":
+        case "service-version-mismatch":
+            return state;
+        case "stopping":
+            return "starting";
+        default:
+            return "unavailable";
+    }
+}
+function mapManagedIndexerHealth(state) {
+    switch (state) {
+        case "synced":
+            return "synced";
+        case "catching-up":
+            return "catching-up";
+        case "reorging":
+            return "reorging";
+        case "starting":
+        case "stopping":
+            return "starting";
+        case "failed":
+            return "failed";
+        case "schema-mismatch":
+            return "schema-mismatch";
+        case "service-version-mismatch":
+            return "service-version-mismatch";
+        default:
+            return "unavailable";
+    }
+}
+function createMiningReadinessSnapshot(options) {
+    const status = options.observedStatus;
+    const bitcoindReachable = status?.rpcReachable === true;
+    const indexerTipAligned = status === null
+        ? null
+        : status.coreBestHeight !== null
+            && status.appliedTipHeight !== null
+            && status.appliedTipHeight === status.coreBestHeight
+            && (status.coreBestHash === null
+                || status.appliedTipHash === null
+                || status.appliedTipHash === status.coreBestHash);
+    return {
+        schemaVersion: 1,
+        walletRootId: options.walletRootId,
+        workerApiVersion: null,
+        workerBinaryVersion: null,
+        workerBuildId: null,
+        updatedAtUnixMs: status?.updatedAtUnixMs ?? Date.now(),
+        runMode: "foreground",
+        backgroundWorkerPid: null,
+        backgroundWorkerRunId: null,
+        backgroundWorkerHeartbeatAtUnixMs: null,
+        backgroundWorkerHealth: null,
+        indexerDaemonState: mapManagedIndexerStateToMiningState(status?.state),
+        indexerDaemonInstanceId: status?.daemonInstanceId ?? null,
+        indexerSnapshotSeq: status?.snapshotSeq ?? null,
+        indexerSnapshotOpenedAtUnixMs: null,
+        indexerTruthSource: "none",
+        indexerHeartbeatAtUnixMs: status?.heartbeatAtUnixMs ?? null,
+        coreBestHeight: status?.coreBestHeight ?? null,
+        coreBestHash: status?.coreBestHash ?? null,
+        indexerTipHeight: status?.appliedTipHeight ?? null,
+        indexerTipHash: status?.appliedTipHash ?? null,
+        indexerReorgDepth: status?.reorgDepth ?? null,
+        indexerTipAligned,
+        corePublishState: bitcoindReachable ? "healthy" : null,
+        providerState: null,
+        lastSuspendDetectedAtUnixMs: null,
+        reconnectSettledUntilUnixMs: null,
+        tipSettledUntilUnixMs: null,
+        miningState: "idle",
+        currentPhase: "waiting-indexer",
+        currentPublishState: "none",
+        targetBlockHeight: status?.coreBestHeight === null || status?.coreBestHeight === undefined
+            ? null
+            : status.coreBestHeight + 1,
+        referencedBlockHashDisplay: null,
+        currentDomainId: null,
+        currentDomainName: null,
+        currentSentenceDisplay: null,
+        currentCanonicalBlend: null,
+        currentTxid: null,
+        currentWtxid: null,
+        livePublishInMempool: null,
+        currentFeeRateSatVb: null,
+        currentAbsoluteFeeSats: null,
+        currentBlockFeeSpentSats: "0",
+        sessionFeeSpentSats: "0",
+        lifetimeFeeSpentSats: "0",
+        sameDomainCompetitorSuppressed: null,
+        higherRankedCompetitorDomainCount: null,
+        dedupedCompetitorDomainCount: null,
+        competitivenessGateIndeterminate: null,
+        mempoolSequenceCacheStatus: null,
+        currentPublishDecision: null,
+        lastMempoolSequence: null,
+        lastCompetitivenessGateAtUnixMs: null,
+        pauseReason: null,
+        providerConfigured: true,
+        providerKind: null,
+        bitcoindHealth: bitcoindReachable ? "ready" : status === null ? "starting" : "unavailable",
+        bitcoindServiceState: bitcoindReachable ? "ready" : status === null ? "starting" : null,
+        bitcoindReplicaStatus: "not-proven",
+        nodeHealth: bitcoindReachable ? "synced" : status === null ? "starting" : "unavailable",
+        indexerHealth: mapManagedIndexerHealth(status?.state),
+        tipsAligned: indexerTipAligned,
+        lastEventAtUnixMs: null,
+        lastError: status?.lastError ?? null,
+        note: null,
+    };
+}
+async function pollManagedMiningReadinessWithVisualizer(options) {
+    while (true) {
+        if (options.signal?.aborted) {
+            throw options.signal.reason instanceof Error
+                ? options.signal.reason
+                : new Error("managed_indexer_observer_aborted");
+        }
+        const status = await options.monitor.getStatus();
+        options.visualizer.update(createMiningReadinessSnapshot({
+            walletRootId: options.walletRootId,
+            observedStatus: status,
+        }), EMPTY_MINING_VISUALIZER_STATE);
+        assertManagedIndexerStatusRecoverable(status);
+        if (isManagedIndexerCaughtUp(status)) {
+            return;
+        }
+        await sleep(options.pollIntervalMs ?? MANAGED_MINING_READINESS_POLL_INTERVAL_MS, options.signal);
+    }
+}
+async function syncManagedMiningReadinessWithVisualizer(options) {
+    let monitor = null;
+    const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
+        paths: options.runtimePaths,
+        provider: options.provider,
+        loadRawWalletStateEnvelope: options.context.loadRawWalletStateEnvelope,
+    });
+    options.visualizer.update(createMiningReadinessSnapshot({
+        walletRootId: walletRoot.walletRootId,
+        observedStatus: null,
+    }), EMPTY_MINING_VISUALIZER_STATE);
+    await options.context.ensureDirectory(dirname(options.databasePath));
+    monitor = await options.context.openManagedIndexerMonitor({
+        dataDir: options.dataDir,
+        databasePath: options.databasePath,
+        walletRootId: walletRoot.walletRootId,
+        expectedBinaryVersion: options.expectedBinaryVersion,
+    });
+    const abortController = new AbortController();
+    const stopWatcher = createCloseSignalWatcher({
+        signalSource: options.context.signalSource,
+        stderr: options.context.stderr,
+        closeable: {
+            close: async () => {
+                abortController.abort(new Error("managed_indexer_preflight_aborted"));
+                await monitor?.close().catch(() => undefined);
+            },
+        },
+        forceExit: options.context.forceExit,
+        firstMessage: "Stopping managed mining readiness observation...",
+        successMessage: "Stopped observing managed mining readiness.",
+        failureMessage: "Managed mining readiness observation cleanup failed.",
+    });
+    try {
+        const syncOutcome = await waitForCompletionOrStop(pollManagedMiningReadinessWithVisualizer({
+            monitor,
+            walletRootId: walletRoot.walletRootId,
+            visualizer: options.visualizer,
+            signal: abortController.signal,
+        }), stopWatcher);
+        if (syncOutcome.kind === "stopped") {
+            return syncOutcome.code;
+        }
+        return null;
+    }
+    finally {
+        stopWatcher.cleanup();
+        await monitor?.close().catch(() => undefined);
+    }
+}
 async function syncManagedMiningReadiness(options) {
     const ttyProgressActive = usesTtyProgress(options.parsed.progressOutput, options.context.stderr);
     let monitor = null;
@@ -121,38 +315,63 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
         const packageVersion = await context.readPackageVersion();
-        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
+        const runtimePaths = context.resolveWalletRuntimePaths();
         if (parsed.command === "mine") {
             const prompter = context.createPrompter();
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
+            const ttyProgressActive = usesTtyProgress(parsed.progressOutput, context.stderr);
             await ensureMiningProviderSetup({
                 context,
                 provider,
                 prompter,
                 runtimePaths,
             });
-            const preflightCode = await syncManagedMiningReadiness({
-                parsed,
-                context,
-                dataDir,
-                databasePath: dbPath,
-                expectedBinaryVersion: packageVersion,
-                provider,
-                runtimePaths,
-            });
-            if (preflightCode !== null) {
-                return preflightCode;
-            }
-            const updateAvailable = usesTtyProgress(parsed.progressOutput, context.stderr)
-                ? await resolveMineUpdateAvailable(packageVersion, context)
-                : false;
-            const abortController = new AbortController();
-            const onStop = () => {
-                abortController.abort();
-            };
-            context.signalSource.on("SIGINT", onStop);
-            context.signalSource.on("SIGTERM", onStop);
+            let visualizer = null;
+            let abortController = null;
+            let onStop = null;
             try {
+                if (ttyProgressActive) {
+                    visualizer = new MiningFollowVisualizer({
+                        clientVersion: packageVersion,
+                        progressOutput: parsed.progressOutput,
+                        stream: context.stderr,
+                    });
+                    visualizer.update(createMiningReadinessSnapshot({
+                        walletRootId: null,
+                        observedStatus: null,
+                    }), EMPTY_MINING_VISUALIZER_STATE);
+                }
+                const preflightCode = ttyProgressActive && visualizer !== null
+                    ? await syncManagedMiningReadinessWithVisualizer({
+                        context,
+                        dataDir,
+                        databasePath: dbPath,
+                        expectedBinaryVersion: packageVersion,
+                        provider,
+                        runtimePaths,
+                        visualizer,
+                    })
+                    : await syncManagedMiningReadiness({
+                        parsed,
+                        context,
+                        dataDir,
+                        databasePath: dbPath,
+                        expectedBinaryVersion: packageVersion,
+                        provider,
+                        runtimePaths,
+                    });
+                if (preflightCode !== null) {
+                    return preflightCode;
+                }
+                const updateAvailable = ttyProgressActive
+                    ? await resolveMineUpdateAvailable(packageVersion, context)
+                    : false;
+                abortController = new AbortController();
+                onStop = () => {
+                    abortController?.abort();
+                };
+                context.signalSource.on("SIGINT", onStop);
+                context.signalSource.on("SIGTERM", onStop);
                 await context.runForegroundMining({
                     clientVersion: packageVersion,
                     updateAvailable,
@@ -166,16 +385,20 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     progressOutput: parsed.progressOutput,
                     builtInSetupEnsured: true,
                     paths: runtimePaths,
+                    visualizer: visualizer ?? undefined,
                 });
             }
             finally {
-                context.signalSource.off("SIGINT", onStop);
-                context.signalSource.off("SIGTERM", onStop);
+                if (onStop !== null) {
+                    context.signalSource.off("SIGINT", onStop);
+                    context.signalSource.off("SIGTERM", onStop);
+                }
+                visualizer?.close();
             }
             return 0;
         }
         if (parsed.command === "mine-start") {
-            const prompter = createCommandPrompter(parsed, context);
+            const prompter = createCommandPrompter(context);
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
             await ensureMiningProviderSetup({
                 context,
@@ -203,14 +426,6 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 builtInSetupEnsured: true,
                 paths: runtimePaths,
             });
-            if (parsed.outputMode === "preview-json") {
-                writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), result.started ? "started" : "already-active", buildMineStartPreviewData(result)));
-                return 0;
-            }
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMiningControlJsonSchema(parsed), "cogcoin mine start", result.started ? "started" : "already-active", buildMineStartData(result)));
-                return 0;
-            }
             if (!result.started) {
                 writeLine(context.stdout, "Background mining is already active.");
                 if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
@@ -225,9 +440,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "mine-stop") {
-            const provider = parsed.outputMode === "text"
-                ? withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter())
-                : context.walletSecretProvider;
+            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter());
             const snapshot = await context.stopBackgroundMining({
                 dataDir,
                 databasePath: dbPath,
@@ -235,18 +448,6 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 paths: runtimePaths,
             });
             const nextSteps = getMineStopNextSteps();
-            if (parsed.outputMode === "preview-json") {
-                writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), snapshot === null ? "not-active" : "stopped", buildMineStopPreviewData(snapshot), {
-                    nextSteps,
-                }));
-                return 0;
-            }
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMiningControlJsonSchema(parsed), "cogcoin mine stop", snapshot === null ? "not-active" : "stopped", buildMineStopData(snapshot), {
-                    nextSteps,
-                }));
-                return 0;
-            }
             writeLine(context.stdout, snapshot?.note ?? "Background mining was not active.");
             for (const line of formatNextStepLines(nextSteps)) {
                 writeLine(context.stdout, line);

package/dist/cli/commands/service-runtime.js

@@ -5,7 +5,7 @@ import { UNINITIALIZED_WALLET_ROOT_ID, resolveManagedServicePaths } from "../../
 import { INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, } from "../../bitcoind/indexer-daemon.js";
 import { resolveWalletRootIdFromLocalArtifacts, } from "../../wallet/root-resolution.js";
 import { writeLine } from "../io.js";
-import { createSuccessEnvelope, describeCanonicalCommand, writeHandledCliError, writeJsonValue, } from "../output.js";
+import { writeHandledCliError, } from "../output.js";
 function formatBool(value) {
     return value === null ? "unknown" : (value ? "yes" : "no");
 }
@@ -286,44 +286,11 @@ function formatIndexerStatusReport(payload) {
             : null,
     });
 }
-function buildStatusMessages(payload) {
-    const warnings = [];
-    const explanations = [];
-    const nextSteps = [];
-    if (payload.compatibility !== "compatible") {
-        warnings.push(`Managed service compatibility is ${payload.compatibility}.`);
-    }
-    if ("nodeError" in payload && payload.nodeError !== null) {
-        explanations.push(payload.nodeError);
-    }
-    if ("service" in payload && payload.service?.lastError) {
-        explanations.push(payload.service.lastError);
-    }
-    if ("daemon" in payload && payload.daemon?.lastError) {
-        explanations.push(payload.daemon.lastError);
-    }
-    if ("service" in payload && payload.compatibility === "unreachable") {
-        nextSteps.push("Run `cogcoin bitcoin start` to start the managed Bitcoin service.");
-    }
-    if ("daemon" in payload && payload.compatibility === "unreachable") {
-        nextSteps.push("Run `cogcoin indexer start` to start the managed Cogcoin indexer.");
-    }
-    return {
-        warnings,
-        explanations,
-        nextSteps,
-    };
-}
 export async function runServiceRuntimeCommand(parsed, context) {
     try {
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
         if (parsed.command === "bitcoin-status") {
             const payload = await inspectManagedBitcoindStatus(dataDir, context);
-            const messages = buildStatusMessages(payload);
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/bitcoin-status/v1", describeCanonicalCommand(parsed), payload, messages));
-                return 0;
-            }
             context.stdout.write(formatBitcoinStatusReport(payload));
             return 0;
         }
@@ -332,11 +299,6 @@ export async function runServiceRuntimeCommand(parsed, context) {
             const packageVersion = await context.readPackageVersion();
             await context.ensureDirectory(dirname(dbPath));
             const payload = await inspectManagedIndexerStatus(dataDir, dbPath, packageVersion, context);
-            const messages = buildStatusMessages(payload);
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/indexer-status/v1", describeCanonicalCommand(parsed), payload, messages));
-                return 0;
-            }
             context.stdout.write(formatIndexerStatusReport(payload));
             return 0;
         }
@@ -364,15 +326,6 @@ export async function runServiceRuntimeCommand(parsed, context) {
                     status: bitcoindStatus,
                 },
             };
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/bitcoin-start/v1", describeCanonicalCommand(parsed), payload, {
-                    nextSteps: [
-                        "Run `cogcoin bitcoin status` to inspect the managed Bitcoin node.",
-                        "Run `cogcoin indexer start` or `cogcoin sync` when you want the managed Cogcoin indexer.",
-                    ],
-                }));
-                return 0;
-            }
             writeLine(context.stdout, bitcoindStatus === "already-running" ? "Managed bitcoind already running." : "Managed bitcoind started.");
             writeLine(context.stdout, `Wallet root: ${resolution.walletRootId}`);
             return 0;
@@ -394,10 +347,6 @@ export async function runServiceRuntimeCommand(parsed, context) {
                 bitcoind,
                 indexer,
             };
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/bitcoin-stop/v1", describeCanonicalCommand(parsed), payload));
-                return 0;
-            }
             writeLine(context.stdout, bitcoind.status === "stopped" ? "Managed bitcoind stopped." : "Managed bitcoind already stopped.");
             writeLine(context.stdout, indexer.status === "stopped" ? "Paired indexer stopped." : "Paired indexer already stopped.");
             return 0;
@@ -440,14 +389,6 @@ export async function runServiceRuntimeCommand(parsed, context) {
                     status: indexerProbe.compatibility === "compatible" ? "already-running" : "started",
                 },
             };
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/indexer-start/v1", describeCanonicalCommand(parsed), payload, {
-                    nextSteps: [
-                        "Run `cogcoin indexer status` to inspect the managed Cogcoin indexer.",
-                    ],
-                }));
-                return 0;
-            }
             writeLine(context.stdout, payload.indexer.status === "already-running" ? "Managed indexer already running." : "Managed indexer started.");
             if (payload.bitcoind.status === "started") {
                 writeLine(context.stdout, "Managed bitcoind started automatically.");
@@ -466,10 +407,6 @@ export async function runServiceRuntimeCommand(parsed, context) {
                 walletRootSource: resolution.source,
                 indexer,
             };
-            if (parsed.outputMode === "json") {
-                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/indexer-stop/v1", describeCanonicalCommand(parsed), payload));
-                return 0;
-            }
             writeLine(context.stdout, indexer.status === "stopped" ? "Managed indexer stopped." : "Managed indexer already stopped.");
             return 0;
         }

package/dist/cli/commands/status.js

@@ -1,19 +1,15 @@
 import { dirname } from "node:path";
-import { buildStatusJson } from "../read-json.js";
 import { formatBalanceReport, formatWalletOverviewReport } from "../wallet-format.js";
 import { writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
-import { createSuccessEnvelope, describeCanonicalCommand, writeJsonValue } from "../output.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 export async function runStatusCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
     const packageVersion = await context.readPackageVersion();
-    const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
+    const runtimePaths = context.resolveWalletRuntimePaths();
     await context.ensureDirectory(dirname(dbPath));
-    const provider = parsed.outputMode === "text"
-        ? withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter?.() ?? createTerminalPrompter(context.stdin, context.stdout))
-        : context.walletSecretProvider;
+    const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter?.() ?? createTerminalPrompter(context.stdin, context.stdout));
     const readContext = await context.openWalletReadContext({
         dataDir,
         databasePath: dbPath,
@@ -22,15 +18,6 @@ export async function runStatusCommand(parsed, context) {
         paths: runtimePaths,
     });
     try {
-        if (parsed.outputMode === "json") {
-            const result = buildStatusJson(readContext);
-            writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/status/v1", describeCanonicalCommand(parsed), result.data, {
-                warnings: result.warnings,
-                explanations: result.explanations,
-                nextSteps: result.nextSteps,
-            }));
-            return 0;
-        }
         writeLine(context.stdout, formatWalletOverviewReport(readContext, packageVersion));
         writeLine(context.stdout, formatBalanceReport(readContext));
         return 0;

package/dist/cli/commands/update.js

@@ -1,5 +1,5 @@
 import { writeLine } from "../io.js";
-import { createMutationSuccessEnvelope, describeCanonicalCommand, resolveStableMutationJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
+import { writeHandledCliError } from "../output.js";
 import { CLI_INSTALL_COMMAND, EXPLICIT_UPDATE_CHECK_TIMEOUT_MS, applyUpdateCheckResult, compareSemver, createEmptyUpdateCheckCache, fetchLatestPublishedVersion, loadUpdateCheckCache, persistUpdateCheckCache, } from "../update-service.js";
 function createUpdateResult(currentVersion, latestVersion, status, applied) {
     return {
@@ -31,10 +31,6 @@ async function confirmApplyUpdate(context) {
         prompter.writeLine("Enter \"y\" to continue or \"n\" to cancel.");
     }
 }
-function writeSuccessJson(parsed, context, result) {
-    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), result.status, result));
-    return 0;
-}
 export async function runUpdateCommand(parsed, context) {
     try {
         const currentVersion = await context.readPackageVersion();
@@ -54,39 +50,28 @@ export async function runUpdateCommand(parsed, context) {
             throw new Error("cli_update_registry_unavailable");
         }
         if (comparison <= 0) {
-            const result = createUpdateResult(currentVersion, latestVersion, "up-to-date", false);
-            if (parsed.outputMode === "json") {
-                return writeSuccessJson(parsed, context, result);
-            }
+            createUpdateResult(currentVersion, latestVersion, "up-to-date", false);
             writeVersionSummary(context, currentVersion, latestVersion);
             writeLine(context.stdout, "Cogcoin is already up to date.");
             return 0;
         }
         if (!parsed.assumeYes) {
-            if (parsed.outputMode !== "text") {
-                throw new Error("cli_update_requires_tty");
-            }
             writeVersionSummary(context, currentVersion, latestVersion);
             if (!(await confirmApplyUpdate(context))) {
                 writeLine(context.stdout, "Update canceled.");
                 return 0;
             }
         }
-        else if (parsed.outputMode === "text") {
+        else {
             writeVersionSummary(context, currentVersion, latestVersion);
         }
-        if (parsed.outputMode === "text") {
-            writeLine(context.stdout, "Installing update...");
-        }
+        writeLine(context.stdout, "Installing update...");
         await context.runGlobalClientUpdateInstall({
-            stdout: parsed.outputMode === "json" ? context.stderr : context.stdout,
+            stdout: context.stdout,
             stderr: context.stderr,
             env: context.env,
         });
-        const result = createUpdateResult(currentVersion, latestVersion, "updated", true);
-        if (parsed.outputMode === "json") {
-            return writeSuccessJson(parsed, context, result);
-        }
+        createUpdateResult(currentVersion, latestVersion, "updated", true);
         writeLine(context.stdout, "Update completed. The next cogcoin invocation will use the new install.");
         return 0;
     }