@cogcoin/client 1.0.0 → 1.0.1

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/context.js

@@ -10,7 +10,7 @@ import { initializeWallet, deleteImportedWalletSeed, previewResetWallet, repairW
 import { resolveWalletRuntimePathsForTesting } from "../wallet/runtime.js";
 import { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
-import { followMiningLog, inspectMiningControlPlane, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, } from "../wallet/mining/index.js";
+import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, } from "../wallet/mining/index.js";
 import { createLazyDefaultWalletSecretProvider } from "../wallet/state/provider.js";
 import { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain, } from "../wallet/tx/index.js";
 import { createTerminalPrompter } from "./prompt.js";
@@ -80,6 +80,7 @@ export function createDefaultContext(overrides = {}) {
         giveReputation: overrides.giveReputation ?? giveReputation,
         revokeReputation: overrides.revokeReputation ?? revokeReputation,
         inspectMiningControlPlane: overrides.inspectMiningControlPlane ?? inspectMiningControlPlane,
+        ensureBuiltInMiningSetupIfNeeded: overrides.ensureBuiltInMiningSetupIfNeeded ?? ensureBuiltInMiningSetupIfNeeded,
         runForegroundMining: overrides.runForegroundMining ?? runForegroundMining,
         startBackgroundMining: overrides.startBackgroundMining ?? startBackgroundMining,
         stopBackgroundMining: overrides.stopBackgroundMining ?? stopBackgroundMining,

package/dist/cli/sync-progress.d.ts

@@ -0,0 +1,6 @@
+import type { ManagedBitcoindProgressEvent } from "../bitcoind/types.js";
+import type { ParsedCliArgs } from "./types.js";
+export declare function createSyncProgressReporter(options: {
+    progressOutput: ParsedCliArgs["progressOutput"];
+    write: (line: string) => void;
+}): (event: ManagedBitcoindProgressEvent) => void;

package/dist/cli/sync-progress.js

@@ -0,0 +1,91 @@
+import { formatBytes, formatDuration } from "../bitcoind/progress/formatting.js";
+const SYNC_PROGRESS_LOG_INTERVAL_MS = 5_000;
+export 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;
+    };
+}

package/dist/cli/types.d.ts

@@ -10,7 +10,7 @@ import type { WalletPrompter, initializeWallet, deleteImportedWalletSeed, previe
 import type { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
 import type { WalletSecretProvider } from "../wallet/state/provider.js";
-import type { followMiningLog, inspectMiningControlPlane, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining } from "../wallet/mining/index.js";
+import type { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining } from "../wallet/mining/index.js";
 import type { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain } from "../wallet/tx/index.js";
 export type ProgressOutput = "auto" | "tty" | "none";
 export type OutputMode = "text" | "json" | "preview-json";
@@ -145,6 +145,7 @@ export interface CliRunnerContext {
     giveReputation?: typeof giveReputation;
     revokeReputation?: typeof revokeReputation;
     inspectMiningControlPlane?: typeof inspectMiningControlPlane;
+    ensureBuiltInMiningSetupIfNeeded?: typeof ensureBuiltInMiningSetupIfNeeded;
     runForegroundMining?: typeof runForegroundMining;
     startBackgroundMining?: typeof startBackgroundMining;
     stopBackgroundMining?: typeof stopBackgroundMining;

package/dist/cli/wallet-format.js

@@ -558,6 +558,9 @@ function getBalanceNextSteps(context) {
             return [`Transfer BTC to ${context.model.walletAddress ?? "this wallet address"} so your anchored root domain can keep mining.`];
         }
         if (context.fundingSpendableSats !== null && context.fundingSpendableSats > BALANCE_MINING_THRESHOLD_SATS) {
+            if (context.mining?.provider.status === "missing") {
+                return ["Run `cogcoin mine setup` to configure your mining provider."];
+            }
             return ["Run `cogcoin mine` to start mining with your anchored root domain."];
         }
         return [];

package/dist/wallet/mining/index.d.ts

@@ -1,6 +1,6 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1, MiningSentenceGenerationResponseV1, } from "./sentence-protocol.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

package/dist/wallet/mining/index.js

@@ -1,5 +1,5 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

package/dist/wallet/mining/runner.d.ts

@@ -137,6 +137,7 @@ export interface RunForegroundMiningOptions extends RunnerDependencies {
     databasePath: string;
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;
+    builtInSetupEnsured?: boolean;
     stdout?: {
         write(chunk: string): void;
     };
@@ -154,6 +155,7 @@ export interface StartBackgroundMiningOptions extends RunnerDependencies {
     databasePath: string;
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;
+    builtInSetupEnsured?: boolean;
     paths?: WalletRuntimePaths;
 }
 export interface StopBackgroundMiningOptions extends RunnerDependencies {
@@ -276,6 +278,11 @@ export declare function publishCandidateForTesting(options: {
     publishAttempt?: typeof publishCandidateOnce;
     appendEventFn?: typeof appendEvent;
 }): Promise<MiningPublishOutcome>;
+export declare function ensureBuiltInMiningSetupIfNeeded(options: {
+    provider: WalletSecretProvider;
+    prompter: WalletPrompter;
+    paths: WalletRuntimePaths;
+}): Promise<boolean>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
 export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
 export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;

package/dist/wallet/mining/runner.js

@@ -1811,7 +1811,7 @@ async function publishCandidate(options) {
 export async function publishCandidateForTesting(options) {
     return await publishCandidate(options);
 }
-async function ensureBuiltInSetupIfNeeded(options) {
+export async function ensureBuiltInMiningSetupIfNeeded(options) {
     const config = await loadClientConfig({
         path: options.paths.clientConfigPath,
         provider: options.provider,
@@ -2732,11 +2732,13 @@ export async function runForegroundMining(options) {
         if (existing?.runMode === "background") {
             throw new Error("Background mining is already active. Run `cogcoin mine stop` first.");
         }
-        const setupReady = await ensureBuiltInSetupIfNeeded({
-            provider,
-            prompter: options.prompter,
-            paths,
-        });
+        const setupReady = options.builtInSetupEnsured === true
+            ? true
+            : await ensureBuiltInMiningSetupIfNeeded({
+                provider,
+                prompter: options.prompter,
+                paths,
+            });
         if (!setupReady) {
             throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
         }
@@ -2801,11 +2803,13 @@ export async function startBackgroundMining(options) {
         if (existing?.runMode === "foreground") {
             throw new Error("Foreground mining is already active. Interrupt that process directly.");
         }
-        const setupReady = await ensureBuiltInSetupIfNeeded({
-            provider,
-            prompter: options.prompter,
-            paths,
-        });
+        const setupReady = options.builtInSetupEnsured === true
+            ? true
+            : await ensureBuiltInMiningSetupIfNeeded({
+                provider,
+                prompter: options.prompter,
+                paths,
+            });
         if (!setupReady) {
             throw new Error("Built-in mining provider is not configured. Run `cogcoin mine setup`.");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",