@cogcoin/client 1.1.5 → 1.1.7

package/dist/wallet/mining/supervisor.js

@@ -1,21 +1,22 @@
-import { randomBytes } from "node:crypto";
-import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { FileLockBusyError, acquireFileLock, clearOrphanedFileLock, readLockMetadata, } from "../fs/lock.js";
 import { openWalletReadContext } from "../read/index.js";
+import { destroyAllClientPasswordSessionsResolved } from "../state/client-password/session.js";
 import { readMiningGenerationActivity, requestMiningGenerationPreemption, } from "./coordination.js";
-import { inspectMiningControlPlane } from "./control.js";
-import { MINING_SHUTDOWN_GRACE_MS, MINING_WORKER_API_VERSION, } from "./constants.js";
+import { MINING_SHUTDOWN_GRACE_MS, } from "./constants.js";
 import { saveStopSnapshot } from "./lifecycle.js";
 import { loadMiningRuntimeStatus, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
+import { createMiningStopRequestedError } from "./stop.js";
 import { MiningFollowVisualizer } from "./visualizer.js";
-const BACKGROUND_START_TIMEOUT_MS = 15_000;
 function sleep(ms, signal) {
     return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
         const timer = setTimeout(resolve, ms);
         signal?.addEventListener("abort", () => {
             clearTimeout(timer);
@@ -23,15 +24,23 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
+function createOneShotClientPasswordSessionDestroyer() {
+    let destroyed = false;
+    return () => {
+        if (destroyed) {
+            return;
+        }
+        destroyed = true;
+        destroyAllClientPasswordSessionsResolved();
+    };
+}
 function resolveSupervisorDependencies(overrides = {}) {
     return {
         requestMiningPreemption: overrides.requestMiningPreemption ?? requestMiningGenerationPreemption,
         saveStopSnapshot: overrides.saveStopSnapshot ?? saveStopSnapshot,
-        spawnWorkerProcess: overrides.spawnWorkerProcess ?? spawn,
         runMiningLoop: overrides.runMiningLoop ?? (() => {
             throw new Error("mining_supervisor_run_loop_missing");
         }),
-        inspectMiningControlPlane: overrides.inspectMiningControlPlane ?? inspectMiningControlPlane,
         loadRuntimeStatus: overrides.loadRuntimeStatus ?? loadMiningRuntimeStatus,
         saveRuntimeStatus: overrides.saveRuntimeStatus ?? saveMiningRuntimeStatus,
         acquireLock: overrides.acquireLock ?? acquireFileLock,
@@ -42,11 +51,17 @@ function resolveSupervisorDependencies(overrides = {}) {
         nowUnixMs: overrides.nowUnixMs ?? Date.now,
         processKill: overrides.processKill ?? process.kill.bind(process),
         processPid: overrides.processPid ?? process.pid,
-        processExecPath: overrides.processExecPath ?? process.execPath,
-        resolveWorkerMainPath: overrides.resolveWorkerMainPath
-            ?? (() => fileURLToPath(new URL("./worker-main.js", import.meta.url))),
+        forceExit: overrides.forceExit ?? ((code) => {
+            process.exit(code);
+        }),
     };
 }
+class ForegroundMiningShutdownTimeoutError extends Error {
+    constructor() {
+        super("mining_foreground_shutdown_timeout");
+        this.name = "ForegroundMiningShutdownTimeoutError";
+    }
+}
 async function isProcessAlive(pid, deps) {
     if (pid === null) {
         return false;
@@ -294,265 +309,143 @@ async function acquireMiningStartControlLock(options) {
         }
     }
 }
-export async function waitForBackgroundHealthy(paths, depsOverrides = {}) {
-    const deps = resolveSupervisorDependencies(depsOverrides);
-    const deadline = deps.nowUnixMs() + BACKGROUND_START_TIMEOUT_MS;
-    while (deps.nowUnixMs() < deadline) {
-        const snapshot = await deps.loadRuntimeStatus(paths.miningStatusPath).catch(() => null);
-        if (snapshot !== null
-            && snapshot.runMode === "background"
-            && snapshot.backgroundWorkerHealth === "healthy") {
-            return snapshot;
-        }
-        await deps.sleep(250);
-    }
-    return deps.loadRuntimeStatus(paths.miningStatusPath).catch(() => null);
-}
 export async function runForegroundMining(options) {
     const deps = resolveSupervisorDependencies(options.deps);
+    const shutdownGraceMs = options.shutdownGraceMs ?? MINING_SHUTDOWN_GRACE_MS;
+    const usesExternalSignal = options.signal !== undefined;
     let visualizer = options.visualizer ?? null;
     const ownsVisualizer = visualizer === null;
+    const destroyClientPasswordSessions = createOneShotClientPasswordSessionDestroyer();
     const controlLock = await acquireMiningStartControlLock({
         paths: options.runtime.paths,
         purpose: "mine-foreground",
         takeoverReason: "mine-foreground-replace",
-        shutdownGraceMs: options.shutdownGraceMs,
+        shutdownGraceMs,
         deps,
     });
     const abortController = new AbortController();
+    let stopRequested = false;
+    let shutdownDeadlineTimer = null;
+    let rejectShutdownDeadline = null;
+    let forceExitIssued = false;
+    const shutdownDeadline = new Promise((_, reject) => {
+        rejectShutdownDeadline = reject;
+    });
+    const requestStop = () => {
+        if (stopRequested) {
+            return;
+        }
+        stopRequested = true;
+        if (!abortController.signal.aborted) {
+            abortController.abort(createMiningStopRequestedError());
+        }
+        shutdownDeadlineTimer = setTimeout(() => {
+            rejectShutdownDeadline?.(new ForegroundMiningShutdownTimeoutError());
+        }, shutdownGraceMs);
+        shutdownDeadlineTimer.unref?.();
+    };
     const abortListener = () => {
-        abortController.abort();
+        requestStop();
     };
-    const handleSigint = () => abortController.abort();
-    const handleSigterm = () => abortController.abort();
-    try {
-        await takeOverMiningRuntime({
-            paths: options.runtime.paths,
-            reason: "mine-foreground-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
-        if (visualizer === null) {
-            visualizer = new MiningFollowVisualizer({
-                clientVersion: options.clientVersion,
-                updateAvailable: options.updateAvailable,
-                progressOutput: options.progressOutput ?? "auto",
-                stream: options.stderr,
+    const handleSigint = () => {
+        requestStop();
+    };
+    const handleSigterm = () => {
+        requestStop();
+    };
+    const issueForcedExit = (code) => {
+        if (forceExitIssued) {
+            return;
+        }
+        forceExitIssued = true;
+        visualizer?.close();
+        destroyClientPasswordSessions();
+        return deps.forceExit(code);
+    };
+    const gracefulRun = async () => {
+        try {
+            await takeOverMiningRuntime({
+                paths: options.runtime.paths,
+                reason: "mine-foreground-replace",
+                shutdownGraceMs,
+                deps,
+            });
+            if (visualizer === null) {
+                visualizer = new MiningFollowVisualizer({
+                    clientVersion: options.clientVersion,
+                    updateAvailable: options.updateAvailable,
+                    progressOutput: options.progressOutput ?? "auto",
+                    stream: options.stderr,
+                });
+            }
+            await deps.runMiningLoop({
+                dataDir: options.dataDir,
+                databasePath: options.databasePath,
+                provider: options.runtime.provider,
+                paths: options.runtime.paths,
+                runMode: "foreground",
+                backgroundWorkerPid: null,
+                backgroundWorkerRunId: null,
+                signal: abortController.signal,
+                fetchImpl: options.fetchImpl,
+                openReadContext: options.runtime.openReadContext,
+                attachService: options.runtime.attachService,
+                rpcFactory: options.runtime.rpcFactory,
+                stdout: options.stdout,
+                visualizer,
+            });
+            await deps.saveStopSnapshot({
+                dataDir: options.dataDir,
+                databasePath: options.databasePath,
+                provider: options.runtime.provider,
+                paths: options.runtime.paths,
+                runMode: "foreground",
+                backgroundWorkerPid: null,
+                backgroundWorkerRunId: null,
+                note: "Foreground mining stopped cleanly.",
             });
         }
-        options.signal?.addEventListener("abort", abortListener, { once: true });
-        process.on("SIGINT", handleSigint);
-        process.on("SIGTERM", handleSigterm);
-        await deps.runMiningLoop({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "foreground",
-            backgroundWorkerPid: null,
-            backgroundWorkerRunId: null,
-            signal: abortController.signal,
-            fetchImpl: options.fetchImpl,
-            openReadContext: options.runtime.openReadContext,
-            attachService: options.runtime.attachService,
-            rpcFactory: options.runtime.rpcFactory,
-            stdout: options.stdout,
-            visualizer,
-        });
-        await deps.saveStopSnapshot({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "foreground",
-            backgroundWorkerPid: null,
-            backgroundWorkerRunId: null,
-            note: "Foreground mining stopped cleanly.",
-        });
-    }
-    finally {
-        options.signal?.removeEventListener("abort", abortListener);
-        process.off("SIGINT", handleSigint);
-        process.off("SIGTERM", handleSigterm);
-        if (ownsVisualizer) {
-            visualizer?.close();
+        finally {
+            if (ownsVisualizer) {
+                visualizer?.close();
+            }
+            await controlLock.release();
+            destroyClientPasswordSessions();
         }
-        await controlLock.release();
-    }
-}
-export async function startBackgroundMining(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const waitForHealthy = options.waitForBackgroundHealthy
-        ?? (async (paths) => await waitForBackgroundHealthy(paths, deps));
-    let controlLock;
+    };
+    const gracefulRunPromise = gracefulRun();
     try {
-        controlLock = await acquireMiningStartControlLock({
-            paths: options.runtime.paths,
-            purpose: "mine-start",
-            takeoverReason: "mine-start-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
+        if (options.signal?.aborted) {
+            requestStop();
+        }
+        else {
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+        }
+        if (!usesExternalSignal) {
+            process.on("SIGINT", handleSigint);
+            process.on("SIGTERM", handleSigterm);
+        }
+        await Promise.race([
+            gracefulRunPromise,
+            shutdownDeadline,
+        ]);
     }
     catch (error) {
-        if (error instanceof FileLockBusyError && error.existingMetadata?.processId === deps.processPid) {
-            return {
-                started: false,
-                snapshot: await deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null),
-            };
+        if (error instanceof ForegroundMiningShutdownTimeoutError) {
+            gracefulRunPromise.catch(() => undefined);
+            issueForcedExit(130);
+            return;
         }
         throw error;
     }
-    try {
-        await takeOverMiningRuntime({
-            paths: options.runtime.paths,
-            reason: "mine-start-replace",
-            shutdownGraceMs: options.shutdownGraceMs,
-            deps,
-        });
-        const runId = randomBytes(16).toString("hex");
-        const child = deps.spawnWorkerProcess(deps.processExecPath, [
-            deps.resolveWorkerMainPath(),
-            `--data-dir=${options.dataDir}`,
-            `--database-path=${options.databasePath}`,
-            `--run-id=${runId}`,
-        ], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-        const snapshot = await waitForHealthy(options.runtime.paths);
-        return {
-            started: true,
-            snapshot,
-        };
-    }
     finally {
-        await controlLock.release();
-    }
-}
-export async function stopBackgroundMining(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const shutdownGraceMs = options.shutdownGraceMs ?? MINING_SHUTDOWN_GRACE_MS;
-    const controlLock = await deps.acquireLock(options.runtime.paths.miningControlLockPath, {
-        purpose: "mine-stop",
-    });
-    try {
-        const snapshot = await deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null);
-        if (snapshot === null || snapshot.runMode !== "background" || snapshot.backgroundWorkerPid === null) {
-            return snapshot;
-        }
-        const preemption = await deps.requestMiningPreemption({
-            paths: options.runtime.paths,
-            reason: "mine-stop",
-            timeoutMs: Math.min(shutdownGraceMs, 15_000),
-        }).catch(() => null);
-        try {
-            try {
-                deps.processKill(snapshot.backgroundWorkerPid, "SIGTERM");
-            }
-            catch (error) {
-                if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
-                    throw error;
-                }
-            }
-            const deadline = deps.nowUnixMs() + shutdownGraceMs;
-            while (deps.nowUnixMs() < deadline) {
-                if (!await isProcessAlive(snapshot.backgroundWorkerPid, deps)) {
-                    break;
-                }
-                await deps.sleep(250);
-            }
-            if (await isProcessAlive(snapshot.backgroundWorkerPid, deps)) {
-                try {
-                    deps.processKill(snapshot.backgroundWorkerPid, "SIGKILL");
-                }
-                catch {
-                    // ignore
-                }
-            }
+        if (shutdownDeadlineTimer !== null) {
+            clearTimeout(shutdownDeadlineTimer);
         }
-        finally {
-            await preemption?.release().catch(() => undefined);
+        options.signal?.removeEventListener("abort", abortListener);
+        if (!usesExternalSignal) {
+            process.off("SIGINT", handleSigint);
+            process.off("SIGTERM", handleSigterm);
         }
-        await deps.saveStopSnapshot({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.runtime.provider,
-            paths: options.runtime.paths,
-            runMode: "background",
-            backgroundWorkerPid: snapshot.backgroundWorkerPid,
-            backgroundWorkerRunId: snapshot.backgroundWorkerRunId,
-            note: snapshot.livePublishInMempool
-                ? "Background mining stopped. The last mining transaction may still confirm from mempool."
-                : "Background mining stopped.",
-        });
-        return deps.loadRuntimeStatus(options.runtime.paths.miningStatusPath).catch(() => null);
-    }
-    finally {
-        await controlLock.release();
-    }
-}
-export async function runBackgroundMiningWorker(options) {
-    const deps = resolveSupervisorDependencies(options.deps);
-    const abortController = new AbortController();
-    process.on("SIGINT", () => abortController.abort());
-    process.on("SIGTERM", () => abortController.abort());
-    const initialContext = await options.runtime.openReadContext({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        secretProvider: options.runtime.provider,
-        paths: options.runtime.paths,
-    });
-    try {
-        const initialView = await deps.inspectMiningControlPlane({
-            provider: options.runtime.provider,
-            localState: initialContext.localState,
-            bitcoind: initialContext.bitcoind,
-            nodeStatus: initialContext.nodeStatus,
-            nodeHealth: initialContext.nodeHealth,
-            indexer: initialContext.indexer,
-            paths: options.runtime.paths,
-        });
-        await deps.saveRuntimeStatus(options.runtime.paths.miningStatusPath, {
-            ...initialView.runtime,
-            walletRootId: initialContext.localState.walletRootId,
-            workerApiVersion: MINING_WORKER_API_VERSION,
-            workerBinaryVersion: process.version,
-            workerBuildId: options.runId,
-            runMode: "background",
-            backgroundWorkerPid: deps.processPid,
-            backgroundWorkerRunId: options.runId,
-            backgroundWorkerHeartbeatAtUnixMs: deps.nowUnixMs(),
-            currentPhase: "idle",
-            updatedAtUnixMs: deps.nowUnixMs(),
-        });
-    }
-    finally {
-        await initialContext.close();
     }
-    await deps.runMiningLoop({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        provider: options.runtime.provider,
-        paths: options.runtime.paths,
-        runMode: "background",
-        backgroundWorkerPid: deps.processPid,
-        backgroundWorkerRunId: options.runId,
-        signal: abortController.signal,
-        fetchImpl: options.fetchImpl,
-        openReadContext: options.runtime.openReadContext,
-        attachService: options.runtime.attachService,
-        rpcFactory: options.runtime.rpcFactory,
-    });
-    await deps.saveStopSnapshot({
-        dataDir: options.dataDir,
-        databasePath: options.databasePath,
-        provider: options.runtime.provider,
-        paths: options.runtime.paths,
-        runMode: "background",
-        backgroundWorkerPid: deps.processPid,
-        backgroundWorkerRunId: options.runId,
-        note: "Background mining worker stopped cleanly.",
-    });
 }

package/dist/wallet/read/context.d.ts

@@ -1,6 +1,6 @@
 import { readSnapshotWithRetry } from "../../bitcoind/indexer-daemon.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletReadContext, WalletServiceHealth } from "./types.js";
+import type { WalletLocalStateStatus, WalletReadContext } from "./types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 declare function inspectWalletLocalState(options?: {
     dataDir?: string;
@@ -9,10 +9,6 @@ declare function inspectWalletLocalState(options?: {
     paths?: WalletRuntimePaths;
     walletControlLockHeld?: boolean;
 }): Promise<WalletLocalStateStatus>;
-export declare function deriveNodeHealthForTesting(status: WalletNodeStatus | null, bitcoindHealth: WalletBitcoindStatus["health"]): {
-    health: WalletServiceHealth;
-    message: string | null;
-};
 export declare function openWalletReadContext(options: {
     dataDir: string;
     databasePath: string;