@cogcoin/client 0.5.0

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

@@ -0,0 +1,173 @@
+import { dirname } from "node:path";
+import { stat } from "node:fs/promises";
+import { formatHooksStatusReport, formatMineStatusReport, formatMiningEventRecord } from "../mining-format.js";
+import { writeLine } from "../io.js";
+import { inspectWalletLocalState } from "../../wallet/read/index.js";
+import { createErrorEnvelope, createSuccessEnvelope, describeCanonicalCommand, normalizeListPage, writeJsonValue, } from "../output.js";
+import { buildHooksStatusJson, buildMineLogJson, buildMineStatusJson } from "../read-json.js";
+import { resolveWalletRuntimePathsForTesting } from "../../wallet/runtime.js";
+async function readRotationIndices() {
+    const paths = resolveWalletRuntimePathsForTesting();
+    const rotation = [];
+    for (let index = 1; index <= 4; index += 1) {
+        try {
+            await stat(`${paths.miningEventsPath}.${index}`);
+            rotation.push(index);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return rotation;
+}
+export async function runMiningReadCommand(parsed, context) {
+    try {
+        const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+        const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        await context.ensureDirectory(dirname(dbPath));
+        if (parsed.command === "hooks-mining-status") {
+            const localState = await inspectWalletLocalState({
+                secretProvider: context.walletSecretProvider,
+            });
+            const view = await context.inspectMiningControlPlane({
+                provider: context.walletSecretProvider,
+                localState,
+                bitcoind: {
+                    health: "unavailable",
+                    status: null,
+                    message: "Managed bitcoind status unavailable during hook inspection.",
+                },
+                nodeStatus: null,
+                nodeHealth: "unavailable",
+                indexer: {
+                    health: "unavailable",
+                    status: null,
+                    message: null,
+                    snapshotTip: null,
+                    source: "none",
+                    daemonInstanceId: null,
+                    snapshotSeq: null,
+                    openedAtUnixMs: null,
+                },
+                verify: parsed.verify,
+            });
+            if (parsed.outputMode === "json") {
+                const result = buildHooksStatusJson(view);
+                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/hooks-status/v1", describeCanonicalCommand(parsed), result.data, {
+                    warnings: result.warnings,
+                    explanations: result.explanations,
+                    nextSteps: result.nextSteps,
+                }));
+                return 0;
+            }
+            writeLine(context.stdout, formatHooksStatusReport(view));
+            return 0;
+        }
+        if (parsed.command === "mine-log") {
+            if (!parsed.follow) {
+                const allEvents = await context.readMiningLog({
+                    all: true,
+                });
+                const defaultLimit = 50;
+                const normalized = normalizeListPage(allEvents.slice().reverse(), {
+                    limit: parsed.listLimit,
+                    all: parsed.listAll,
+                    defaultLimit,
+                });
+                const events = normalized.items.slice().reverse();
+                if (events.length === 0) {
+                    if (parsed.outputMode === "json") {
+                        const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                        writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
+                            warnings: result.warnings,
+                            explanations: result.explanations,
+                            nextSteps: result.nextSteps,
+                        }));
+                        return 0;
+                    }
+                    writeLine(context.stdout, "No mining events recorded yet.");
+                    return 0;
+                }
+                if (parsed.outputMode === "json") {
+                    const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                    writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
+                        warnings: result.warnings,
+                        explanations: result.explanations,
+                        nextSteps: result.nextSteps,
+                    }));
+                    return 0;
+                }
+                for (const event of events) {
+                    writeLine(context.stdout, formatMiningEventRecord(event));
+                }
+                if (normalized.page.truncated && normalized.page.limit !== null && normalized.page.totalKnown !== null) {
+                    writeLine(context.stdout, `Showing latest ${normalized.page.returned} of ${normalized.page.totalKnown}. Use --limit <n> or --all for more.`);
+                }
+                return 0;
+            }
+            const abortController = new AbortController();
+            const onStop = () => {
+                abortController.abort();
+            };
+            context.signalSource.on("SIGINT", onStop);
+            context.signalSource.on("SIGTERM", onStop);
+            try {
+                await context.followMiningLog({
+                    signal: abortController.signal,
+                    onEvent: (event) => {
+                        writeLine(context.stdout, formatMiningEventRecord(event));
+                    },
+                });
+            }
+            finally {
+                context.signalSource.off("SIGINT", onStop);
+                context.signalSource.off("SIGTERM", onStop);
+            }
+            return 0;
+        }
+        const readContext = await context.openWalletReadContext({
+            dataDir,
+            databasePath: dbPath,
+            secretProvider: context.walletSecretProvider,
+        });
+        try {
+            const mining = readContext.mining ?? await context.inspectMiningControlPlane({
+                provider: context.walletSecretProvider,
+                localState: readContext.localState,
+                bitcoind: readContext.bitcoind,
+                nodeStatus: readContext.nodeStatus,
+                nodeHealth: readContext.nodeHealth,
+                indexer: readContext.indexer,
+            });
+            if (parsed.outputMode === "json") {
+                const result = buildMineStatusJson(mining);
+                writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-status/v1", describeCanonicalCommand(parsed), result.data, {
+                    warnings: result.warnings,
+                    explanations: result.explanations,
+                    nextSteps: result.nextSteps,
+                }));
+                return 0;
+            }
+            writeLine(context.stdout, formatMineStatusReport(mining));
+            return 0;
+        }
+        finally {
+            await readContext.close();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (parsed.outputMode === "json") {
+            writeJsonValue(context.stdout, createErrorEnvelope(parsed.command === "hooks-mining-status"
+                ? "cogcoin/hooks-status/v1"
+                : parsed.command === "mine-log"
+                    ? "cogcoin/mine-log/v1"
+                    : "cogcoin/mine-status/v1", describeCanonicalCommand(parsed), message, message));
+            return 5;
+        }
+        writeLine(context.stderr, message);
+        return 5;
+    }
+}

package/dist/cli/commands/mining-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function runMiningRuntimeCommand(parsed: ParsedCliArgs, context: RequiredCliRunnerContext): Promise<number>;

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

@@ -0,0 +1,108 @@
+import { dirname } from "node:path";
+import { buildMineStartData, buildMineStopData, } from "../mining-json.js";
+import { buildMineStartPreviewData, buildMineStopPreviewData, } from "../preview-json.js";
+import { writeLine } from "../io.js";
+import { createTerminalPrompter } from "../prompt.js";
+import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMiningControlJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
+import { formatNextStepLines, getMineStopNextSteps, } from "../workflow-hints.js";
+function createCommandPrompter(parsed, context) {
+    return parsed.outputMode !== "text"
+        ? createTerminalPrompter(context.stdin, context.stderr)
+        : context.createPrompter();
+}
+export async function runMiningRuntimeCommand(parsed, context) {
+    try {
+        const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+        const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const provider = context.walletSecretProvider;
+        await context.ensureDirectory(dirname(dbPath));
+        if (parsed.command === "mine") {
+            const abortController = new AbortController();
+            const onStop = () => {
+                abortController.abort();
+            };
+            context.signalSource.on("SIGINT", onStop);
+            context.signalSource.on("SIGTERM", onStop);
+            try {
+                await context.runForegroundMining({
+                    dataDir,
+                    databasePath: dbPath,
+                    provider,
+                    prompter: context.createPrompter(),
+                    signal: abortController.signal,
+                    stdout: context.stdout,
+                    stderr: context.stderr,
+                    progressOutput: parsed.progressOutput,
+                });
+            }
+            finally {
+                context.signalSource.off("SIGINT", onStop);
+                context.signalSource.off("SIGTERM", onStop);
+            }
+            return 0;
+        }
+        if (parsed.command === "mine-start") {
+            const result = await context.startBackgroundMining({
+                dataDir,
+                databasePath: dbPath,
+                provider,
+                prompter: createCommandPrompter(parsed, context),
+            });
+            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) {
+                    writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
+                }
+                return 0;
+            }
+            writeLine(context.stdout, "Started background mining.");
+            if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
+                writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
+            }
+            return 0;
+        }
+        if (parsed.command === "mine-stop") {
+            const snapshot = await context.stopBackgroundMining({
+                dataDir,
+                databasePath: dbPath,
+                provider,
+            });
+            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);
+            }
+            return 0;
+        }
+        writeLine(context.stderr, `mining runtime command not implemented: ${parsed.command}`);
+        return 1;
+    }
+    catch (error) {
+        return writeHandledCliError({
+            parsed,
+            stdout: context.stdout,
+            stderr: context.stderr,
+            error,
+        });
+    }
+}

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function runStatusCommand(parsed: ParsedCliArgs, context: RequiredCliRunnerContext): Promise<number>;

package/dist/cli/commands/status.js

@@ -0,0 +1,31 @@
+import { dirname } from "node:path";
+import { buildStatusJson } from "../read-json.js";
+import { formatWalletOverviewReport } from "../wallet-format.js";
+import { writeLine } from "../io.js";
+import { createSuccessEnvelope, describeCanonicalCommand, writeJsonValue } from "../output.js";
+export async function runStatusCommand(parsed, context) {
+    const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+    const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    await context.ensureDirectory(dirname(dbPath));
+    const readContext = await context.openWalletReadContext({
+        dataDir,
+        databasePath: dbPath,
+        secretProvider: context.walletSecretProvider,
+    });
+    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));
+        return 0;
+    }
+    finally {
+        await readContext.close();
+    }
+}

package/dist/cli/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function runSyncCommand(parsed: ParsedCliArgs, context: RequiredCliRunnerContext): Promise<number>;

package/dist/cli/commands/sync.js

@@ -0,0 +1,52 @@
+import { dirname } from "node:path";
+import { formatManagedSyncErrorMessage } from "../../bitcoind/errors.js";
+import { writeLine } from "../io.js";
+import { classifyCliError } from "../output.js";
+import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
+export async function runSyncCommand(parsed, context) {
+    const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+    const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    await context.ensureDirectory(dirname(dbPath));
+    const store = await context.openSqliteStore({ filename: dbPath });
+    let storeOwned = true;
+    try {
+        const client = await context.openManagedBitcoindClient({
+            store,
+            databasePath: dbPath,
+            dataDir,
+            progressOutput: parsed.progressOutput,
+        });
+        storeOwned = false;
+        const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);
+        try {
+            const syncOutcome = await waitForCompletionOrStop(client.syncToTip(), stopWatcher);
+            if (syncOutcome.kind === "stopped") {
+                return syncOutcome.code;
+            }
+            const result = syncOutcome.value;
+            if (typeof client.playSyncCompletionScene === "function") {
+                const completionOutcome = await waitForCompletionOrStop(client.playSyncCompletionScene().catch(() => undefined), stopWatcher);
+                if (completionOutcome.kind === "stopped") {
+                    return completionOutcome.code;
+                }
+            }
+            writeLine(context.stdout, `Applied blocks: ${result.appliedBlocks}`);
+            writeLine(context.stdout, `Rewound blocks: ${result.rewoundBlocks}`);
+            writeLine(context.stdout, `Indexed ending height: ${result.endingHeight ?? "none"}`);
+            writeLine(context.stdout, `Node best height: ${result.bestHeight}`);
+            return 0;
+        }
+        finally {
+            stopWatcher.cleanup();
+            await client.close();
+        }
+    }
+    catch (error) {
+        const message = formatManagedSyncErrorMessage(error instanceof Error ? error.message : String(error));
+        writeLine(context.stderr, `sync failed: ${message}`);
+        if (storeOwned) {
+            await store.close().catch(() => undefined);
+        }
+        return classifyCliError(error).exitCode;
+    }
+}

package/dist/cli/commands/wallet-admin.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function runWalletAdminCommand(parsed: ParsedCliArgs, context: RequiredCliRunnerContext): Promise<number>;

package/dist/cli/commands/wallet-admin.js

@@ -0,0 +1,175 @@
+import { parseUnlockDurationToMs } from "../../wallet/lifecycle.js";
+import { buildInitMutationData, buildUnlockMutationData, buildRepairMutationData, buildWalletExportMutationData, buildWalletImportMutationData, buildWalletLockMutationData, } from "../mutation-json.js";
+import { buildRepairPreviewData, buildWalletLockPreviewData, } from "../preview-json.js";
+import { writeLine } from "../io.js";
+import { createTerminalPrompter } from "../prompt.js";
+import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMutationJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, } from "../workflow-hints.js";
+function createCommandPrompter(parsed, context) {
+    return parsed.outputMode !== "text"
+        ? createTerminalPrompter(context.stdin, context.stderr)
+        : context.createPrompter();
+}
+function getRepairWarnings(result) {
+    return result.miningResumeAction === "resume-failed"
+        ? [`Wallet repair succeeded, but background mining did not resume automatically: ${result.miningResumeError ?? "unknown error"}`]
+        : [];
+}
+export async function runWalletAdminCommand(parsed, context) {
+    try {
+        const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+        const provider = context.walletSecretProvider;
+        if (parsed.command === "init" || parsed.command === "wallet-init") {
+            const prompter = createCommandPrompter(parsed, context);
+            const result = await context.initializeWallet({
+                dataDir,
+                provider,
+                prompter,
+            });
+            const nextSteps = getInitNextSteps();
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "initialized", buildInitMutationData(result), {
+                    explanations: [getFundingQuickstartGuidance()],
+                    nextSteps,
+                }));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet initialized.`);
+            writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+            writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
+            writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
+            writeLine(context.stdout, `Quickstart: ${getFundingQuickstartGuidance()}`);
+            for (const line of formatNextStepLines(nextSteps)) {
+                writeLine(context.stdout, line);
+            }
+            return 0;
+        }
+        if (parsed.command === "unlock" || parsed.command === "wallet-unlock") {
+            const durationMs = parseUnlockDurationToMs(parsed.unlockFor);
+            const result = await context.unlockWallet({
+                provider,
+                unlockDurationMs: durationMs,
+            });
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "unlocked", buildUnlockMutationData(result)));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet unlocked.`);
+            writeLine(context.stdout, `Wallet root: ${result.state.walletRootId}`);
+            writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
+            return 0;
+        }
+        if (parsed.command === "wallet-export") {
+            const prompter = createCommandPrompter(parsed, context);
+            const result = await context.exportWallet({
+                archivePath: parsed.args[0],
+                dataDir,
+                databasePath: dbPath,
+                provider,
+                prompter,
+            });
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "exported", buildWalletExportMutationData(result)));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet exported.`);
+            writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+            writeLine(context.stdout, `Archive path: ${result.archivePath}`);
+            return 0;
+        }
+        if (parsed.command === "wallet-import") {
+            const prompter = createCommandPrompter(parsed, context);
+            const result = await context.importWallet({
+                archivePath: parsed.args[0],
+                dataDir,
+                databasePath: dbPath,
+                provider,
+                prompter,
+            });
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "imported", buildWalletImportMutationData(result)));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet imported.`);
+            writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+            writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
+            writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
+            return 0;
+        }
+        if (parsed.command === "wallet-lock") {
+            const result = await context.lockWallet({
+                dataDir,
+                provider,
+            });
+            if (parsed.outputMode === "preview-json") {
+                writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "locked", buildWalletLockPreviewData(result)));
+                return 0;
+            }
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin wallet lock", "locked", buildWalletLockMutationData(result)));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet locked.`);
+            writeLine(context.stdout, `Wallet root: ${result.walletRootId ?? "none"}`);
+            return 0;
+        }
+        if (parsed.command === "repair") {
+            const result = await context.repairWallet({
+                dataDir,
+                databasePath: dbPath,
+                provider,
+                assumeYes: parsed.assumeYes,
+            });
+            if (parsed.outputMode === "preview-json") {
+                writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "completed", buildRepairPreviewData(result), {
+                    nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                    warnings: getRepairWarnings(result),
+                }));
+                return 0;
+            }
+            if (parsed.outputMode === "json") {
+                writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin repair", "completed", buildRepairMutationData(result), {
+                    nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                    warnings: getRepairWarnings(result),
+                }));
+                return 0;
+            }
+            writeLine(context.stdout, `Wallet repair completed.`);
+            writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+            writeLine(context.stdout, `Recovered from backup: ${result.recoveredFromBackup ? "yes" : "no"}`);
+            writeLine(context.stdout, `Managed Core wallet recreated: ${result.recreatedManagedCoreWallet ? "yes" : "no"}`);
+            writeLine(context.stdout, `Managed bitcoind action: ${result.bitcoindServiceAction}`);
+            writeLine(context.stdout, `Managed bitcoind compatibility issue: ${result.bitcoindCompatibilityIssue}`);
+            writeLine(context.stdout, `Managed Core replica action: ${result.managedCoreReplicaAction}`);
+            writeLine(context.stdout, `Managed bitcoind post-repair health: ${result.bitcoindPostRepairHealth}`);
+            writeLine(context.stdout, `Indexer database reset: ${result.resetIndexerDatabase ? "yes" : "no"}`);
+            writeLine(context.stdout, `Indexer daemon action: ${result.indexerDaemonAction}`);
+            writeLine(context.stdout, `Indexer compatibility issue: ${result.indexerCompatibilityIssue}`);
+            writeLine(context.stdout, `Indexer post-repair health: ${result.indexerPostRepairHealth}`);
+            writeLine(context.stdout, `Mining mode before repair: ${result.miningPreRepairRunMode}`);
+            writeLine(context.stdout, `Mining resume action: ${result.miningResumeAction}`);
+            writeLine(context.stdout, `Mining mode after repair: ${result.miningPostRepairRunMode}`);
+            if (result.miningResumeError !== null) {
+                writeLine(context.stdout, `Mining resume error: ${result.miningResumeError}`);
+            }
+            if (result.note !== null) {
+                writeLine(context.stdout, `Note: ${result.note}`);
+            }
+            for (const warning of getRepairWarnings(result)) {
+                writeLine(context.stdout, `Warning: ${warning}`);
+            }
+            return 0;
+        }
+        writeLine(context.stderr, `wallet admin command not implemented: ${parsed.command}`);
+        return 1;
+    }
+    catch (error) {
+        return writeHandledCliError({
+            parsed,
+            stdout: context.stdout,
+            stderr: context.stderr,
+            error,
+        });
+    }
+}

package/dist/cli/commands/wallet-mutation.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function runWalletMutationCommand(parsed: ParsedCliArgs, context: RequiredCliRunnerContext): Promise<number>;