@cogcoin/client 1.0.0 → 1.0.2

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@1.0.0` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@1.0.2` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 
@@ -130,6 +130,7 @@ Managed node subpath:
 
 The installed `cogcoin` command covers the first-party local wallet and node workflow:
 
+- update commands such as `update` to compare the current CLI version with the latest npm release and install it
 - wallet lifecycle commands such as `init`, `restore`, `wallet delete`, `wallet show-mnemonic`, and `repair`
 - sync and service commands such as `status`, `sync`, `follow`, `bitcoin start`, `bitcoin stop`, `bitcoin status`, `indexer start`, `indexer stop`, and `indexer status`
 - domain and field commands such as `register`, `anchor`, `show`, `domains`, `fields`, `buy`, `sell`, and `transfer`

package/dist/bitcoind/indexer-daemon.d.ts

@@ -84,6 +84,7 @@ export interface CoherentIndexerSnapshotLease {
     payload: IndexerSnapshotPayload;
     status: ManagedIndexerDaemonStatus;
 }
+type ManagedIndexerDaemonServiceLifetime = "persistent" | "ephemeral";
 export declare function stopIndexerDaemonServiceWithLockHeld(options: {
     dataDir: string;
     walletRootId?: string;
@@ -104,6 +105,8 @@ export declare function attachOrStartIndexerDaemon(options: {
     databasePath: string;
     walletRootId?: string;
     startupTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    serviceLifetime?: ManagedIndexerDaemonServiceLifetime;
 }): Promise<IndexerDaemonClient>;
 export declare function stopIndexerDaemonService(options: {
     dataDir: string;

package/dist/bitcoind/indexer-daemon.js

@@ -80,7 +80,8 @@ export async function stopIndexerDaemonServiceWithLockHeld(options) {
         walletRootId,
     };
 }
-function createIndexerDaemonClient(socketPath) {
+function createIndexerDaemonClient(socketPath, closeOptions = null) {
+    let closed = false;
     async function sendRequest(request) {
         return new Promise((resolve, reject) => {
             const socket = net.createConnection(socketPath);
@@ -181,7 +182,18 @@ function createIndexerDaemonClient(socketPath) {
             });
         },
         async close() {
-            return;
+            if (closed) {
+                return;
+            }
+            closed = true;
+            if (closeOptions === null || closeOptions.serviceLifetime !== "ephemeral" || closeOptions.ownership === "attached") {
+                return;
+            }
+            await stopIndexerDaemonService({
+                dataDir: closeOptions.dataDir,
+                walletRootId: closeOptions.walletRootId,
+                shutdownTimeoutMs: closeOptions.shutdownTimeoutMs,
+            });
         },
     };
 }
@@ -308,7 +320,8 @@ async function waitForIndexerDaemon(dataDir, walletRootId, timeoutMs) {
     while (Date.now() < deadline) {
         const probe = await probeIndexerDaemonAtSocket(paths.indexerDaemonSocketPath, walletRootId);
         if (probe.compatibility === "compatible" && probe.client !== null) {
-            return probe.client;
+            await probe.client.close().catch(() => undefined);
+            return;
         }
         if (probe.compatibility !== "unreachable") {
             throw new Error(probe.error ?? "indexer_daemon_protocol_error");
@@ -358,6 +371,7 @@ export async function attachOrStartIndexerDaemon(options) {
     const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
     const paths = resolveManagedServicePaths(options.dataDir, walletRootId);
     const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+    const serviceLifetime = options.serviceLifetime ?? "persistent";
     const existingProbe = await probeIndexerDaemonAtSocket(paths.indexerDaemonSocketPath, walletRootId);
     if (existingProbe.compatibility === "compatible" && existingProbe.client !== null) {
         return existingProbe.client;
@@ -382,17 +396,46 @@ export async function attachOrStartIndexerDaemon(options) {
             }
             await mkdir(paths.indexerServiceRoot, { recursive: true });
             const daemonEntryPath = fileURLToPath(new URL("./indexer-daemon-main.js", import.meta.url));
+            const spawnOptions = serviceLifetime === "ephemeral"
+                ? {
+                    stdio: "ignore",
+                }
+                : {
+                    detached: true,
+                    stdio: "ignore",
+                };
             const child = spawn(process.execPath, [
                 daemonEntryPath,
                 `--data-dir=${options.dataDir}`,
                 `--database-path=${options.databasePath}`,
                 `--wallet-root-id=${walletRootId}`,
             ], {
-                detached: true,
-                stdio: "ignore",
+                ...spawnOptions,
+            });
+            if (serviceLifetime !== "ephemeral") {
+                child.unref();
+            }
+            try {
+                await waitForIndexerDaemon(options.dataDir, walletRootId, startupTimeoutMs);
+            }
+            catch (error) {
+                if (child.pid !== undefined) {
+                    try {
+                        process.kill(child.pid, "SIGTERM");
+                    }
+                    catch {
+                        // ignore shutdown failures while unwinding startup errors
+                    }
+                }
+                throw error;
+            }
+            return createIndexerDaemonClient(paths.indexerDaemonSocketPath, {
+                dataDir: options.dataDir,
+                walletRootId,
+                serviceLifetime,
+                ownership: "started",
+                shutdownTimeoutMs: options.shutdownTimeoutMs,
             });
-            child.unref();
-            return await waitForIndexerDaemon(options.dataDir, walletRootId, startupTimeoutMs);
         }
         finally {
             await lock.release();
@@ -400,7 +443,14 @@ export async function attachOrStartIndexerDaemon(options) {
     }
     catch (error) {
         if (error instanceof FileLockBusyError) {
-            return waitForIndexerDaemon(options.dataDir, walletRootId, startupTimeoutMs);
+            await waitForIndexerDaemon(options.dataDir, walletRootId, startupTimeoutMs);
+            return createIndexerDaemonClient(paths.indexerDaemonSocketPath, {
+                dataDir: options.dataDir,
+                walletRootId,
+                serviceLifetime,
+                ownership: "attached",
+                shutdownTimeoutMs: options.shutdownTimeoutMs,
+            });
         }
         throw error;
     }

package/dist/bitcoind/retryable-rpc.js

@@ -19,6 +19,9 @@ export function isRetryableManagedRpcError(error) {
     if (message === "bitcoind_rpc_timeout") {
         return true;
     }
+    if (/^bitcoind_rpc_[^_]+_-28(?:_|$)/.test(message)) {
+        return true;
+    }
     if (message.startsWith("The managed Bitcoin RPC request to ")) {
         return message.includes(" failed");
     }

package/dist/bitcoind/service.d.ts

@@ -24,6 +24,7 @@ type ManagedBitcoindServiceOptions = Pick<InternalManagedBitcoindOptions, "dataD
     getblockArchivePath?: string | null;
     getblockArchiveEndHeight?: number | null;
     getblockArchiveSha256?: string | null;
+    serviceLifetime?: "persistent" | "ephemeral";
 };
 export type ManagedBitcoindServiceCompatibility = "compatible" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch" | "unreachable" | "protocol-error";
 export interface ManagedBitcoindServiceProbeResult {

package/dist/bitcoind/service.js

@@ -681,9 +681,10 @@ async function refreshManagedBitcoindStatus(status, paths, options) {
         return nextStatus;
     }
 }
-function createNodeHandle(status, paths, options) {
+function createNodeHandle(status, paths, options, ownership) {
     let currentStatus = status;
     const rpc = createRpcClient(currentStatus.rpc);
+    let stopped = false;
     return {
         rpc: currentStatus.rpc,
         zmq: currentStatus.zmq,
@@ -706,9 +707,20 @@ function createNodeHandle(status, paths, options) {
             return currentStatus;
         },
         async stop() {
-            // Public managed clients detach from the persistent service instead of
-            // shutting it down on ordinary command exit.
-            return;
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            if (options.serviceLifetime !== "ephemeral" || ownership === "attached") {
+                // Public managed clients detach from persistent services, and ephemeral
+                // attach callers must not shut down services they did not launch.
+                return;
+            }
+            await stopManagedBitcoindService({
+                dataDir: currentStatus.dataDir,
+                walletRootId: currentStatus.walletRootId,
+                shutdownTimeoutMs: options.shutdownTimeoutMs,
+            });
         },
     };
 }
@@ -720,7 +732,7 @@ async function tryAttachExistingManagedBitcoindService(options) {
         return null;
     }
     const refreshed = await refreshManagedBitcoindStatus(probe.status, paths, options);
-    return createNodeHandle(refreshed, paths, options);
+    return createNodeHandle(refreshed, paths, options, "attached");
 }
 async function waitForManagedBitcoindService(options, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
@@ -765,6 +777,7 @@ export async function attachOrStartManagedBitcoindService(options) {
     const resolvedOptions = {
         ...options,
         dataDir: options.dataDir,
+        serviceLifetime: options.serviceLifetime ?? "persistent",
         walletRootId: options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
     };
     const startupTimeoutMs = resolvedOptions.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
@@ -815,11 +828,20 @@ export async function attachOrStartManagedBitcoindService(options) {
                         port: runtimeConfig.zmqPort,
                         pollIntervalMs: startOptions.pollIntervalMs ?? 15_000,
                     };
+                    const spawnOptions = startOptions.serviceLifetime === "ephemeral"
+                        ? {
+                            stdio: "ignore",
+                        }
+                        : {
+                            detached: true,
+                            stdio: "ignore",
+                        };
                     const child = spawn(bitcoindPath, buildManagedServiceArgs(startOptions, runtimeConfig), {
-                        detached: true,
-                        stdio: "ignore",
+                        ...spawnOptions,
                     });
-                    child.unref();
+                    if (startOptions.serviceLifetime !== "ephemeral") {
+                        child.unref();
+                    }
                     const rpc = createRpcClient(rpcConfig);
                     try {
                         await waitForRpcReady(rpc, rpcConfig.cookieFile, startOptions.chain, startupTimeoutMs);
@@ -876,7 +898,7 @@ export async function attachOrStartManagedBitcoindService(options) {
                     });
                 }
                 await writeBitcoindStatus(paths, status);
-                return createNodeHandle(status, paths, resolvedOptions);
+                return createNodeHandle(status, paths, resolvedOptions, "started");
             }
             finally {
                 await lock.release();

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

@@ -36,6 +36,15 @@ export async function runMiningAdminCommand(parsed, context) {
             }
             writeLine(context.stdout, "Built-in mining provider configured.");
             writeLine(context.stdout, `Provider: ${view.provider.provider ?? "unknown"}`);
+            if (view.provider.modelId !== null) {
+                writeLine(context.stdout, `Selected model: ${view.provider.modelId}`);
+            }
+            if (view.provider.modelSelectionSource !== null) {
+                writeLine(context.stdout, `Selection source: ${view.provider.modelSelectionSource}`);
+            }
+            if (view.provider.estimatedDailyCostDisplay !== null) {
+                writeLine(context.stdout, `Approximate daily cost: ${view.provider.estimatedDailyCostDisplay}`);
+            }
             for (const line of formatNextStepLines(nextSteps)) {
                 writeLine(context.stdout, line);
             }

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

@@ -1,28 +1,109 @@
 import { dirname } from "node:path";
+import { FileLockBusyError, acquireFileLock } from "../../wallet/fs/lock.js";
+import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
+import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 import { buildMineStartData, buildMineStopData, } from "../mining-json.js";
 import { buildMineStartPreviewData, buildMineStopPreviewData, } from "../preview-json.js";
-import { writeLine } from "../io.js";
+import { usesTtyProgress, 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";
-import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
+import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
+import { createSyncProgressReporter } from "../sync-progress.js";
 function createCommandPrompter(parsed, context) {
     return parsed.outputMode !== "text"
         ? createTerminalPrompter(context.stdin, context.stderr)
         : context.createPrompter();
 }
-async function prestartManagedMiningServices(options) {
-    let readContext = null;
+async function ensureMiningProviderSetup(options) {
+    const setupReady = await options.context.ensureBuiltInMiningSetupIfNeeded({
+        provider: options.provider,
+        prompter: options.prompter,
+        paths: options.runtimePaths,
+    });
+    if (!setupReady) {
+        throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
+    }
+}
+async function syncManagedMiningReadiness(options) {
+    const ttyProgressActive = usesTtyProgress(options.parsed.progressOutput, options.context.stderr);
+    let controlLock = null;
+    let store = null;
+    let storeOwned = true;
+    let client = null;
+    let clientClosed = false;
     try {
-        readContext = await options.context.openWalletReadContext({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            secretProvider: options.provider,
+        const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
             paths: options.runtimePaths,
+            provider: options.provider,
+            loadRawWalletStateEnvelope: options.context.loadRawWalletStateEnvelope,
         });
+        try {
+            controlLock = await acquireFileLock(options.runtimePaths.walletControlLockPath, {
+                purpose: "managed-sync",
+                walletRootId: walletRoot.walletRootId,
+            });
+        }
+        catch (error) {
+            if (error instanceof FileLockBusyError) {
+                throw new Error("wallet_control_lock_busy");
+            }
+            throw error;
+        }
+        await options.context.ensureDirectory(dirname(options.databasePath));
+        store = await options.context.openSqliteStore({ filename: options.databasePath });
+        client = await options.context.openManagedBitcoindClient({
+            store,
+            databasePath: options.databasePath,
+            dataDir: options.dataDir,
+            walletRootId: walletRoot.walletRootId,
+            progressOutput: options.parsed.progressOutput,
+            onProgress: ttyProgressActive ? undefined : createSyncProgressReporter({
+                progressOutput: options.parsed.progressOutput,
+                write: (line) => {
+                    writeLine(options.context.stderr, line);
+                },
+            }),
+        });
+        storeOwned = false;
+        const stopWatcher = createStopSignalWatcher(options.context.signalSource, options.context.stderr, client, options.context.forceExit, [options.runtimePaths.walletControlLockPath]);
+        try {
+            const syncOutcome = await waitForCompletionOrStop(client.syncToTip(), stopWatcher);
+            if (syncOutcome.kind === "stopped") {
+                return syncOutcome.code;
+            }
+            const result = syncOutcome.value;
+            if (result.endingHeight !== null && result.endingHeight === result.bestHeight) {
+                stopWatcher.cleanup();
+                const detachPromise = typeof client.detachToBackgroundFollow === "function"
+                    ? client.detachToBackgroundFollow()
+                    : Promise.resolve();
+                try {
+                    await detachPromise;
+                    await client.close();
+                    clientClosed = true;
+                    writeLine(options.context.stderr, "Detached cleanly; background indexer follow resumed.");
+                    return null;
+                }
+                catch {
+                    writeLine(options.context.stderr, "Detach failed before background indexer follow was confirmed.");
+                    return 1;
+                }
+            }
+            throw new Error("Managed sync did not reach the current Bitcoin tip.");
+        }
+        finally {
+            stopWatcher.cleanup();
+            if (!clientClosed) {
+                await client.close();
+            }
+        }
     }
     finally {
-        await readContext?.close();
+        if (storeOwned && store !== null) {
+            await store.close().catch(() => undefined);
+        }
+        await controlLock?.release().catch(() => undefined);
     }
 }
 export async function runMiningRuntimeCommand(parsed, context) {
@@ -30,17 +111,26 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
         const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
-        await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "mine") {
             const prompter = context.createPrompter();
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
-            await prestartManagedMiningServices({
+            await ensureMiningProviderSetup({
+                context,
+                provider,
+                prompter,
+                runtimePaths,
+            });
+            const preflightCode = await syncManagedMiningReadiness({
+                parsed,
                 context,
                 dataDir,
                 databasePath: dbPath,
                 provider,
                 runtimePaths,
             });
+            if (preflightCode !== null) {
+                return preflightCode;
+            }
             const abortController = new AbortController();
             const onStop = () => {
                 abortController.abort();
@@ -57,6 +147,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     stdout: context.stdout,
                     stderr: context.stderr,
                     progressOutput: parsed.progressOutput,
+                    builtInSetupEnsured: true,
                     paths: runtimePaths,
                 });
             }
@@ -69,18 +160,29 @@ export async function runMiningRuntimeCommand(parsed, context) {
         if (parsed.command === "mine-start") {
             const prompter = createCommandPrompter(parsed, context);
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
-            await prestartManagedMiningServices({
+            await ensureMiningProviderSetup({
+                context,
+                provider,
+                prompter,
+                runtimePaths,
+            });
+            const preflightCode = await syncManagedMiningReadiness({
+                parsed,
                 context,
                 dataDir,
                 databasePath: dbPath,
                 provider,
                 runtimePaths,
             });
+            if (preflightCode !== null) {
+                return preflightCode;
+            }
             const result = await context.startBackgroundMining({
                 dataDir,
                 databasePath: dbPath,
                 provider,
                 prompter,
+                builtInSetupEnsured: true,
                 paths: runtimePaths,
             });
             if (parsed.outputMode === "preview-json") {

package/dist/cli/commands/sync.js

@@ -1,6 +1,5 @@
 import { dirname } from "node:path";
 import { formatManagedSyncErrorMessage } from "../../bitcoind/errors.js";
-import { formatBytes, formatDuration } from "../../bitcoind/progress/formatting.js";
 import { FileLockBusyError, acquireFileLock } from "../../wallet/fs/lock.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
@@ -8,8 +7,8 @@ import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError, formatCliTextError } from "../output.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
+import { createSyncProgressReporter } from "../sync-progress.js";
 import { formatBalanceReport } from "../wallet-format.js";
-const SYNC_PROGRESS_LOG_INTERVAL_MS = 5_000;
 async function writePostSyncBalanceReport(options) {
     const provider = withInteractiveWalletSecretProvider(options.context.walletSecretProvider, options.context.createPrompter?.() ?? createTerminalPrompter(options.context.stdin, options.context.stdout));
     const readContext = await options.context.openWalletReadContext({
@@ -26,95 +25,6 @@ async function writePostSyncBalanceReport(options) {
         await readContext.close().catch(() => undefined);
     }
 }
-function createSyncProgressReporter(options) {
-    let lastPhase = null;
-    let lastMessage = "";
-    let lastDownloadPrintedAt = 0;
-    let lastDownloadBytes = null;
-    let lastImportPrintedAt = 0;
-    let lastImportBlocks = null;
-    const infoEnabled = options.progressOutput !== "none";
-    function shouldPrintEntryMessage(message, phase) {
-        if (message === "Waiting to start managed sync." || message === "Sync complete.") {
-            return false;
-        }
-        if (message.startsWith("Warning:")) {
-            return true;
-        }
-        if (!infoEnabled) {
-            return false;
-        }
-        if (phase === "getblock_archive_download" || phase === "getblock_archive_import") {
-            return true;
-        }
-        return phase === "snapshot_download"
-            || phase === "wait_headers_for_snapshot"
-            || phase === "load_snapshot"
-            || phase === "bitcoin_sync"
-            || phase === "cogcoin_sync"
-            || message.includes("Getblock manifest")
-            || message.startsWith("Fetching Getblock manifest.")
-            || message.startsWith("Refreshing Getblock manifest.")
-            || message.startsWith("Using Getblock range ");
-    }
-    function formatDownloadLine(label, event) {
-        const current = event.progress.downloadedBytes ?? 0;
-        const total = event.progress.totalBytes ?? 0;
-        const percent = event.progress.percent ?? (total > 0 ? (current / total) * 100 : 0);
-        const speed = event.progress.bytesPerSecond === null ? "--" : `${formatBytes(event.progress.bytesPerSecond)}/s`;
-        return `${label}: ${percent.toFixed(2)}% (${formatBytes(current)} / ${formatBytes(total)}, ${speed}, ETA ${formatDuration(event.progress.etaSeconds)})`;
-    }
-    return (event) => {
-        const message = event.progress.message.trim();
-        const phaseChanged = event.phase !== lastPhase;
-        const messageChanged = message !== lastMessage;
-        if ((phaseChanged || messageChanged) && shouldPrintEntryMessage(message, event.phase)) {
-            options.write(message);
-        }
-        if (infoEnabled && event.phase === "getblock_archive_download") {
-            const now = Date.now();
-            const currentBytes = event.progress.downloadedBytes ?? 0;
-            const isComplete = (event.progress.percent ?? 0) >= 100;
-            const shouldPrintMilestone = phaseChanged
-                || lastDownloadBytes !== currentBytes && (isComplete
-                    || now - lastDownloadPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(formatDownloadLine("Getblock download", event));
-                lastDownloadPrintedAt = now;
-                lastDownloadBytes = currentBytes;
-            }
-        }
-        else if (infoEnabled && event.phase === "snapshot_download") {
-            const now = Date.now();
-            const currentBytes = event.progress.downloadedBytes ?? 0;
-            const isComplete = (event.progress.percent ?? 0) >= 100;
-            const shouldPrintMilestone = phaseChanged
-                || lastDownloadBytes !== currentBytes && (isComplete
-                    || now - lastDownloadPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(formatDownloadLine("Snapshot download", event));
-                lastDownloadPrintedAt = now;
-                lastDownloadBytes = currentBytes;
-            }
-        }
-        else if (infoEnabled && event.phase === "getblock_archive_import") {
-            const now = Date.now();
-            const currentBlocks = event.progress.blocks ?? 0;
-            const targetBlocks = event.progress.targetHeight ?? currentBlocks;
-            const isComplete = currentBlocks >= targetBlocks;
-            const shouldPrintMilestone = phaseChanged
-                || lastImportBlocks !== currentBlocks && (isComplete
-                    || now - lastImportPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(`Getblock import: Bitcoin ${currentBlocks.toLocaleString()} / ${targetBlocks.toLocaleString()}`);
-                lastImportPrintedAt = now;
-                lastImportBlocks = currentBlocks;
-            }
-        }
-        lastPhase = event.phase;
-        lastMessage = message;
-    };
-}
 export async function runSyncCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();

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

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