@cogcoin/client 1.2.3 → 1.2.5

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

@@ -38,7 +38,10 @@ function getResetNextSteps(result) {
         ? ["Run `cogcoin init` to create or restore a wallet."]
         : ["Run `cogcoin sync` to bootstrap assumeutxo and the managed Bitcoin/indexer state."];
 }
-function getRepairNextSteps() {
+function getRepairNextSteps(result) {
+    if (result.bitcoindPostRepairHealth === "starting") {
+        return ["Wait for Bitcoin Core to finish loading, then run `cogcoin status` or rerun `cogcoin mine`."];
+    }
     return ["Run `cogcoin status` to review the repaired local state."];
 }
 function formatResetBitcoinDataDirStatus(result) {
@@ -116,7 +119,7 @@ function buildRepairWarningEntries(result) {
     return entries;
 }
 function formatRepairResultText(result) {
-    const nextStep = getRepairNextSteps()[0] ?? null;
+    const nextStep = getRepairNextSteps(result)[0] ?? null;
     const warningEntries = buildRepairWarningEntries(result);
     const sections = [
         formatAdminSection("Wallet", [
@@ -244,6 +247,9 @@ export async function runWalletAdminCommand(parsed, context) {
                     provider: repairProvider,
                     assumeYes: parsed.assumeYes,
                     paths: runtimePaths,
+                    progress: async (event) => {
+                        writeLine(context.stdout, event.message);
+                    },
                 });
                 writeLine(context.stdout, formatRepairResultText(result));
                 return 0;

package/dist/cli/context.js

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService, } from "../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService, } from "../bitcoind/service.js";
+import { refreshManagedBitcoindStatus } from "../bitcoind/managed-bitcoind-service-status.js";
 import { resolveDefaultBitcoindDataDirForTesting, resolveDefaultClientDatabasePathForTesting, resolveDefaultUpdateCheckStatePathForTesting, } from "../app-paths.js";
 import { openManagedBitcoindClient } from "../bitcoind/index.js";
 import { openManagedIndexerMonitor } from "../bitcoind/indexer-monitor.js";
@@ -106,6 +107,7 @@ export function createDefaultContext(overrides = {}) {
         }),
         attachManagedBitcoindService: overrides.attachManagedBitcoindService ?? attachOrStartManagedBitcoindService,
         probeManagedBitcoindService: overrides.probeManagedBitcoindService ?? probeManagedBitcoindService,
+        refreshManagedBitcoindServiceStatus: overrides.refreshManagedBitcoindServiceStatus ?? refreshManagedBitcoindStatus,
         stopManagedBitcoindService: overrides.stopManagedBitcoindService ?? stopManagedBitcoindService,
         createBitcoinRpcClient: overrides.createBitcoinRpcClient ?? createRpcClient,
         attachIndexerDaemon: overrides.attachIndexerDaemon ?? attachOrStartIndexerDaemon,

package/dist/cli/output/rules/cli-surface.js

@@ -77,6 +77,13 @@ export const cliSurfaceErrorRules = [
                 next: "Drop `--satvb` for this command, or use it with a wallet mutation command like `cogcoin register` or `cogcoin send`.",
             };
         }
+        if (errorCode === "cli_live_not_supported_for_command") {
+            return {
+                what: "This command does not support `--live`.",
+                why: "`--live` only applies to `cogcoin status`, where it opts into RPC-backed wallet and service checks.",
+                next: "Drop `--live`, or run `cogcoin status --live`.",
+            };
+        }
         if (errorCode === "cli_anchor_clear_removed") {
             return {
                 what: "`anchor clear` is no longer available.",

package/dist/cli/output/rules/services.js

@@ -21,6 +21,13 @@ export const serviceErrorRules = [
                 next: "Rerun the command in an interactive terminal.",
             };
         }
+        if (errorCode === "managed_bitcoind_service_starting" || /^bitcoind_rpc_[^_]+_-28(?:_|$)/.test(errorCode)) {
+            return {
+                what: "Bitcoin Core is still loading.",
+                why: "The managed Bitcoin RPC service is alive, but Bitcoin Core is still warming up and returned its normal startup -28 response.",
+                next: "Wait for the node to finish loading, then rerun the command. Use `cogcoin status` to check readiness.",
+            };
+        }
         if (errorCode.includes("tip_mismatch") || errorCode.includes("stale") || errorCode.includes("catching_up") || errorCode.includes("starting")) {
             return {
                 what: "Trusted service state is not ready.",

package/dist/cli/parse.js

@@ -37,6 +37,7 @@ export function parseCliArgs(argv) {
     let listLimit = null;
     let listAll = false;
     let follow = false;
+    let statusLive = false;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === "--help") {
@@ -238,6 +239,10 @@ export function parseCliArgs(argv) {
             follow = true;
             continue;
         }
+        if (token === "--live") {
+            statusLive = true;
+            continue;
+        }
         if (token === "--yes") {
             assumeYes = true;
             continue;
@@ -448,6 +453,9 @@ export function parseCliArgs(argv) {
     if (follow && command !== "mine-log") {
         throw new Error("cli_follow_not_supported_for_command");
     }
+    if (statusLive && command !== "status") {
+        throw new Error("cli_live_not_supported_for_command");
+    }
     if (command === "mine-log" && follow && (listAll || listLimit !== null)) {
         throw new Error("cli_follow_limit_not_supported");
     }
@@ -502,5 +510,6 @@ export function parseCliArgs(argv) {
         listLimit,
         listAll,
         follow,
+        statusLive,
     };
 }

package/dist/cli/status-format.d.ts

@@ -1,2 +1,2 @@
-import type { inspectPassiveClientStatus } from "../passive-status.js";
-export declare function formatStatusReport(status: Awaited<ReturnType<typeof inspectPassiveClientStatus>>): string;
+import type { PassiveClientStatus } from "../passive-status.js";
+export declare function formatStatusReport(status: PassiveClientStatus, version: string): string;

package/dist/cli/status-format.js

@@ -1,48 +1,187 @@
+function row(ok, text) {
+    return { ok, text };
+}
+function formatMarker(ok) {
+    return ok ? "✓" : "✗";
+}
+function formatValue(value) {
+    return value === null || value === undefined || value === "" ? "none" : String(value);
+}
+function formatYesNo(value) {
+    return value ? "yes" : "no";
+}
 function formatBootstrapPercent(current, total) {
     if (total <= 0) {
         return "0.00";
     }
     return ((current / total) * 100).toFixed(2);
 }
-export function formatStatusReport(status) {
-    const lines = [
-        "Cogcoin Client Status",
-        `DB path: ${status.dbPath}`,
-        `Bitcoin datadir: ${status.bitcoinDataDir}`,
-        `Store exists: ${status.storeExists ? "yes" : "no"}`,
-        `Store initialized: ${status.storeInitialized ? "yes" : "no"}`,
+function formatSignedDelta(value) {
+    if (value > 0) {
+        return `+${value}`;
+    }
+    return String(value);
+}
+function formatSection(title, rows) {
+    return [
+        title,
+        ...rows.map((entry) => `${formatMarker(entry.ok)} ${entry.text}`),
+    ].join("\n");
+}
+function buildPathsRows(status) {
+    return [
+        row(true, `DB path: ${status.dbPath}`),
+        row(true, `Bitcoin datadir: ${status.bitcoinDataDir}`),
+    ];
+}
+function buildWalletRows(status) {
+    const rows = [
+        row(status.wallet.walletRootId !== null && status.wallet.error === null, `Wallet root: ${status.wallet.walletRootId ?? "unknown"} (${status.wallet.source})`),
+    ];
+    if (status.wallet.error !== null) {
+        rows.push(row(false, `Wallet root error: ${status.wallet.error}`));
+    }
+    return rows;
+}
+function buildLocalStoreRows(status) {
+    const rows = [
+        row(status.storeExists, `Store exists: ${formatYesNo(status.storeExists)}`),
+        row(status.storeInitialized, `Store initialized: ${formatYesNo(status.storeInitialized)}`),
     ];
     if (status.storeError !== null) {
-        lines.push(`Store error: ${status.storeError}`);
+        rows.push(row(false, `Store error: ${status.storeError}`));
     }
     if (status.indexedTip === null) {
-        lines.push("Indexed tip: none");
+        rows.push(row(false, "Indexed tip: none"));
     }
     else {
-        lines.push(`Indexed tip height: ${status.indexedTip.height}`);
-        lines.push(`Indexed tip hash: ${status.indexedTip.blockHashHex}`);
-        lines.push(`Indexed tip state hash: ${status.indexedTip.stateHashHex ?? "none"}`);
+        rows.push(row(true, `Indexed tip height: ${status.indexedTip.height}`));
+        rows.push(row(true, `Indexed tip hash: ${status.indexedTip.blockHashHex}`));
+        rows.push(row(status.indexedTip.stateHashHex !== null, `Indexed tip state hash: ${formatValue(status.indexedTip.stateHashHex)}`));
     }
     if (status.latestCheckpoint === null) {
-        lines.push("Latest checkpoint: none");
+        rows.push(row(false, "Latest checkpoint: none"));
     }
     else {
-        lines.push(`Latest checkpoint height: ${status.latestCheckpoint.height}`);
-        lines.push(`Latest checkpoint hash: ${status.latestCheckpoint.blockHashHex}`);
+        rows.push(row(true, `Latest checkpoint height: ${status.latestCheckpoint.height}`));
+        rows.push(row(true, `Latest checkpoint hash: ${status.latestCheckpoint.blockHashHex}`));
+    }
+    if (status.indexedTip !== null && status.indexer.appliedTipHeight !== null) {
+        const delta = status.indexedTip.height - status.indexer.appliedTipHeight;
+        rows.push(row(Math.abs(delta) <= 1, `Store/indexer height delta: ${formatSignedDelta(delta)}`));
     }
+    return rows;
+}
+function buildBootstrapRows(status) {
     if (status.bootstrap === null) {
-        lines.push("Bootstrap state: none");
+        return [row(false, "Bootstrap state: none")];
     }
-    else {
-        lines.push(`Bootstrap phase: ${status.bootstrap.phase}`);
-        lines.push(`Bootstrap download: ${status.bootstrap.downloadedBytes} / ${status.bootstrap.totalBytes} bytes (${formatBootstrapPercent(status.bootstrap.downloadedBytes, status.bootstrap.totalBytes)}%)`);
-        lines.push(`Bootstrap validated: ${status.bootstrap.validated ? "yes" : "no"}`);
-        lines.push(`Bootstrap loaded: ${status.bootstrap.loadTxOutSetComplete ? "yes" : "no"}`);
-        lines.push(`Bootstrap base height: ${status.bootstrap.baseHeight ?? "none"}`);
-        lines.push(`Bootstrap tip hash: ${status.bootstrap.tipHashHex ?? "none"}`);
-        lines.push(`Bootstrap snapshot height: ${status.bootstrap.snapshotHeight ?? "none"}`);
-        lines.push(`Bootstrap last error: ${status.bootstrap.lastError ?? "none"}`);
-    }
-    lines.push("Live node: not checked (passive status)");
-    return lines.join("\n");
+    return [
+        row(status.bootstrap.lastError === null, `Bootstrap phase: ${status.bootstrap.phase}`),
+        row(status.bootstrap.lastError === null, `Bootstrap download: ${status.bootstrap.downloadedBytes} / ${status.bootstrap.totalBytes} bytes (${formatBootstrapPercent(status.bootstrap.downloadedBytes, status.bootstrap.totalBytes)}%)`),
+        row(status.bootstrap.validated, `Bootstrap validated: ${formatYesNo(status.bootstrap.validated)}`),
+        row(status.bootstrap.loadTxOutSetComplete, `Bootstrap loaded: ${formatYesNo(status.bootstrap.loadTxOutSetComplete)}`),
+        row(status.bootstrap.baseHeight !== null, `Bootstrap base height: ${formatValue(status.bootstrap.baseHeight)}`),
+        row(status.bootstrap.tipHashHex !== null, `Bootstrap tip hash: ${formatValue(status.bootstrap.tipHashHex)}`),
+        row(status.bootstrap.snapshotHeight !== null, `Bootstrap snapshot height: ${formatValue(status.bootstrap.snapshotHeight)}`),
+        row(status.bootstrap.lastError === null, `Bootstrap last error: ${formatValue(status.bootstrap.lastError)}`),
+    ];
+}
+function buildManagedBitcoindRows(status) {
+    if (status.managedBitcoind.error !== null) {
+        return [
+            row(false, "Managed bitcoind: corrupt"),
+            row(false, `Managed bitcoind status path: ${formatValue(status.managedBitcoind.statusPath)}`),
+            row(false, `Managed bitcoind status error: ${status.managedBitcoind.error}`),
+        ];
+    }
+    if (!status.managedBitcoind.present) {
+        return [row(false, "Managed bitcoind: unavailable")];
+    }
+    return [
+        row(status.managedBitcoind.state === "ready", `Managed bitcoind: ${formatValue(status.managedBitcoind.state)}`),
+        row(status.managedBitcoind.processId !== null, `Managed bitcoind pid: ${formatValue(status.managedBitcoind.processId)}`),
+        row(status.managedBitcoind.walletRootId !== null, `Managed bitcoind wallet root: ${formatValue(status.managedBitcoind.walletRootId)}`),
+        row(status.managedBitcoind.heartbeatAtUnixMs !== null, `Managed bitcoind heartbeat: ${formatValue(status.managedBitcoind.heartbeatAtUnixMs)}`),
+        row(status.managedBitcoind.updatedAtUnixMs !== null, `Managed bitcoind updated: ${formatValue(status.managedBitcoind.updatedAtUnixMs)}`),
+        row(status.managedBitcoind.lastError === null, `Managed bitcoind last error: ${formatValue(status.managedBitcoind.lastError)}`),
+    ];
+}
+function buildIndexerRows(status) {
+    if (status.indexer.error !== null) {
+        return [
+            row(false, "Indexer: corrupt"),
+            row(false, `Indexer status path: ${formatValue(status.indexer.statusPath)}`),
+            row(false, `Indexer status error: ${status.indexer.error}`),
+        ];
+    }
+    if (!status.indexer.present) {
+        return [row(false, "Indexer: unavailable")];
+    }
+    const rows = [
+        row(status.indexer.state === "synced", `Indexer: ${formatValue(status.indexer.state)}`),
+        row(status.indexer.processId !== null, `Indexer pid: ${formatValue(status.indexer.processId)}`),
+        row(status.indexer.walletRootId !== null, `Indexer wallet root: ${formatValue(status.indexer.walletRootId)}`),
+        row(status.indexer.coreBestHeight !== null, `Indexer core best height: ${formatValue(status.indexer.coreBestHeight)}`),
+        row(status.indexer.appliedTipHeight !== null, `Indexer applied tip height: ${formatValue(status.indexer.appliedTipHeight)}`),
+        row(status.indexer.appliedTipHash !== null, `Indexer applied tip hash: ${formatValue(status.indexer.appliedTipHash)}`),
+        row(status.indexer.heartbeatAtUnixMs !== null, `Indexer heartbeat: ${formatValue(status.indexer.heartbeatAtUnixMs)}`),
+        row(status.indexer.updatedAtUnixMs !== null, `Indexer updated: ${formatValue(status.indexer.updatedAtUnixMs)}`),
+        row(status.indexer.lastError === null, `Indexer last error: ${formatValue(status.indexer.lastError)}`),
+    ];
+    if (status.indexer.coreBestHeight !== null && status.indexer.appliedTipHeight !== null) {
+        const lag = Math.max(0, status.indexer.coreBestHeight - status.indexer.appliedTipHeight);
+        rows.push(row(lag === 0, `Indexer lag: ${lag} blocks`));
+    }
+    return rows;
+}
+function buildManagedServicesRows(status) {
+    return [
+        ...buildManagedBitcoindRows(status),
+        ...buildIndexerRows(status),
+    ];
+}
+function buildMiningRows(status) {
+    if (status.mining.error !== null) {
+        return [
+            row(false, "Mining state: corrupt"),
+            row(false, `Mining status path: ${formatValue(status.mining.statusPath)}`),
+            row(false, `Mining status error: ${status.mining.error}`),
+        ];
+    }
+    if (!status.mining.present) {
+        return [row(false, "Mining state: unavailable")];
+    }
+    const miningHasError = status.mining.lastError !== null;
+    const needsBackgroundWorker = status.mining.runMode === "background";
+    return [
+        row(!miningHasError, `Mining run mode: ${formatValue(status.mining.runMode)}`),
+        row(!miningHasError, `Mining state: ${formatValue(status.mining.miningState)}`),
+        row(!miningHasError, `Mining phase: ${formatValue(status.mining.currentPhase)}`),
+        row(!needsBackgroundWorker || status.mining.backgroundWorkerPid !== null, `Mining background worker pid: ${formatValue(status.mining.backgroundWorkerPid)}`),
+        row(!needsBackgroundWorker || status.mining.backgroundWorkerHealth !== null, `Mining background worker health: ${formatValue(status.mining.backgroundWorkerHealth)}`),
+        row(status.mining.updatedAtUnixMs !== null, `Mining updated: ${formatValue(status.mining.updatedAtUnixMs)}`),
+        row(!miningHasError, `Mining last error: ${formatValue(status.mining.lastError)}`),
+        row(status.mining.note === null, `Mining note: ${formatValue(status.mining.note)}`),
+    ];
+}
+function buildPassiveModeRows() {
+    return [
+        row(true, "Live node: not checked"),
+        row(true, "Password prompt: not required"),
+        row(true, "RPC-backed balance: not checked"),
+    ];
+}
+export function formatStatusReport(status, version) {
+    return [
+        `⛭ Cogcoin Status v${version} (passive) ⛭`,
+        formatSection("Paths", buildPathsRows(status)),
+        formatSection("Wallet", buildWalletRows(status)),
+        formatSection("Local Store", buildLocalStoreRows(status)),
+        formatSection("Bootstrap", buildBootstrapRows(status)),
+        formatSection("Managed Services", buildManagedServicesRows(status)),
+        formatSection("Mining", buildMiningRows(status)),
+        formatSection("Passive Mode", buildPassiveModeRows()),
+        "Run cogcoin status --live for RPC-backed balance and full service verification.",
+    ].join("\n\n");
 }

package/dist/cli/types.d.ts

@@ -4,6 +4,7 @@ import { createRpcClient } from "../bitcoind/node.js";
 import type { ManagedBitcoindProgressEvent } from "../bitcoind/types.js";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService } from "../bitcoind/indexer-daemon.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService } from "../bitcoind/service.js";
+import type { refreshManagedBitcoindStatus } from "../bitcoind/managed-bitcoind-service-status.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import type { ClientStoreAdapter } from "../types.js";
 import type { WalletRuntimePaths } from "../wallet/runtime.js";
@@ -64,6 +65,7 @@ export interface ParsedCliArgs {
     listLimit: number | null;
     listAll: boolean;
     follow: boolean;
+    statusLive: boolean;
 }
 export interface ManagedClientLike {
     syncToTip(): Promise<{
@@ -115,6 +117,7 @@ export interface CliRunnerContext {
     openManagedIndexerMonitor?: typeof openManagedIndexerMonitor;
     attachManagedBitcoindService?: typeof attachOrStartManagedBitcoindService;
     probeManagedBitcoindService?: typeof probeManagedBitcoindService;
+    refreshManagedBitcoindServiceStatus?: typeof refreshManagedBitcoindStatus;
     stopManagedBitcoindService?: typeof stopManagedBitcoindService;
     createBitcoinRpcClient?: typeof createRpcClient;
     attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;

package/dist/passive-status.d.ts

@@ -1,3 +1,4 @@
+import type { WalletRuntimePaths } from "./wallet/runtime.js";
 interface PassiveTipStatus {
     height: number;
     blockHashHex: string;
@@ -22,15 +23,62 @@ interface PassiveBootstrapStatus {
     snapshotHeight: number | null;
     updatedAt: number | null;
 }
+export interface PassiveWalletStatus {
+    walletRootId: string | null;
+    source: "wallet-state" | "none" | "unreadable";
+    error: string | null;
+}
+export interface PassiveManagedBitcoindStatus {
+    statusPath: string | null;
+    present: boolean;
+    state: string | null;
+    processId: number | null;
+    walletRootId: string | null;
+    heartbeatAtUnixMs: number | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    error: string | null;
+}
+export interface PassiveIndexerStatus {
+    statusPath: string | null;
+    present: boolean;
+    state: string | null;
+    processId: number | null;
+    walletRootId: string | null;
+    coreBestHeight: number | null;
+    appliedTipHeight: number | null;
+    appliedTipHash: string | null;
+    heartbeatAtUnixMs: number | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    error: string | null;
+}
+export interface PassiveMiningStatus {
+    statusPath: string | null;
+    present: boolean;
+    runMode: string | null;
+    miningState: string | null;
+    currentPhase: string | null;
+    backgroundWorkerPid: number | null;
+    backgroundWorkerHealth: string | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    note: string | null;
+    error: string | null;
+}
 export interface PassiveClientStatus {
     dbPath: string;
     bitcoinDataDir: string;
+    wallet: PassiveWalletStatus;
     storeInitialized: boolean;
     storeExists: boolean;
     indexedTip: PassiveTipStatus | null;
     latestCheckpoint: PassiveCheckpointStatus | null;
     bootstrap: PassiveBootstrapStatus | null;
+    managedBitcoind: PassiveManagedBitcoindStatus;
+    indexer: PassiveIndexerStatus;
+    mining: PassiveMiningStatus;
     storeError: string | null;
 }
-export declare function inspectPassiveClientStatus(dbPath: string, bitcoinDataDir: string): Promise<PassiveClientStatus>;
+export declare function inspectPassiveClientStatus(dbPath: string, bitcoinDataDir: string, runtimePaths?: WalletRuntimePaths): Promise<PassiveClientStatus>;
 export {};