@cogcoin/client 1.1.7 → 1.1.9

package/dist/wallet/reset/process-cleanup.js

@@ -0,0 +1,179 @@
+import { loadMiningRuntimeStatus } from "../mining/runtime-artifacts.js";
+import { acquireFileLock } from "../fs/lock.js";
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+import { readJsonFileOrNull } from "./artifacts.js";
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function resolveProcessCleanupDependencies(overrides = {}) {
+    return {
+        acquireLock: overrides.acquireLock ?? acquireFileLock,
+        processKill: overrides.processKill ?? process.kill.bind(process),
+        sleep: overrides.sleep ?? sleep,
+    };
+}
+export async function isProcessAlive(pid, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    if (pid === null) {
+        return false;
+    }
+    try {
+        resolved.processKill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+            return false;
+        }
+        return true;
+    }
+}
+export async function waitForProcessExit(pid, timeoutMs = 15_000, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!await isProcessAlive(pid, resolved)) {
+            return true;
+        }
+        await resolved.sleep(100);
+    }
+    return !await isProcessAlive(pid, resolved);
+}
+export async function terminateTrackedProcesses(trackedProcesses, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const survivors = new Set();
+    for (const processInfo of trackedProcesses) {
+        try {
+            resolved.processKill(processInfo.pid, "SIGTERM");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                throw error;
+            }
+        }
+    }
+    for (const processInfo of trackedProcesses) {
+        if (!await waitForProcessExit(processInfo.pid, 5_000, resolved)) {
+            survivors.add(processInfo.pid);
+        }
+    }
+    for (const pid of survivors) {
+        try {
+            resolved.processKill(pid, "SIGKILL");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+                throw error;
+            }
+        }
+    }
+    const remaining = new Set();
+    for (const pid of survivors) {
+        if (!await waitForProcessExit(pid, 5_000, resolved)) {
+            remaining.add(pid);
+        }
+    }
+    if (remaining.size > 0) {
+        throw new Error("reset_process_shutdown_failed");
+    }
+    return {
+        managedBitcoind: trackedProcesses.filter((processInfo) => processInfo.kind === "managed-bitcoind").length,
+        indexerDaemon: trackedProcesses.filter((processInfo) => processInfo.kind === "indexer-daemon").length,
+        backgroundMining: trackedProcesses.filter((processInfo) => processInfo.kind === "background-mining").length,
+        survivors: 0,
+    };
+}
+export async function collectTrackedManagedProcesses(paths, deps = {}) {
+    const trackedProcesses = [];
+    const trackedProcessKinds = new Set();
+    const serviceLockPaths = new Set();
+    const runtimeEntries = await readdir(paths.runtimeRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of runtimeEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const serviceRoot = join(paths.runtimeRoot, entry.name);
+        const bitcoindStatus = await readJsonFileOrNull(join(serviceRoot, "bitcoind-status.json"));
+        if (bitcoindStatus?.processId != null && await isProcessAlive(bitcoindStatus.processId, deps)) {
+            trackedProcesses.push({
+                kind: "managed-bitcoind",
+                pid: bitcoindStatus.processId,
+            });
+            trackedProcessKinds.add("managed-bitcoind");
+            serviceLockPaths.add(join(serviceRoot, "bitcoind.lock"));
+        }
+    }
+    const indexerEntries = await readdir(paths.indexerRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of indexerEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const status = await readJsonFileOrNull(join(paths.indexerRoot, entry.name, "status.json"));
+        if (status?.processId != null && await isProcessAlive(status.processId, deps)) {
+            trackedProcesses.push({
+                kind: "indexer-daemon",
+                pid: status.processId,
+            });
+            trackedProcessKinds.add("indexer-daemon");
+            serviceLockPaths.add(join(paths.runtimeRoot, entry.name, "indexer-daemon.lock"));
+        }
+    }
+    const miningRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
+    if (miningRuntime?.backgroundWorkerPid != null
+        && await isProcessAlive(miningRuntime.backgroundWorkerPid, deps)) {
+        trackedProcesses.push({
+            kind: "background-mining",
+            pid: miningRuntime.backgroundWorkerPid,
+        });
+        trackedProcessKinds.add("background-mining");
+    }
+    const seen = new Set();
+    const deduped = trackedProcesses.filter((processInfo) => {
+        const key = `${processInfo.kind}:${processInfo.pid}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    return {
+        trackedProcesses: deduped,
+        trackedProcessKinds: [...trackedProcessKinds],
+        serviceLockPaths: [...serviceLockPaths].sort(),
+    };
+}
+export async function acquireResetLocks(paths, serviceLockPaths, deps = {}) {
+    const resolved = resolveProcessCleanupDependencies(deps);
+    const lockPaths = [
+        paths.walletControlLockPath,
+        paths.miningControlLockPath,
+        ...serviceLockPaths,
+    ];
+    const handles = [];
+    try {
+        for (const lockPath of lockPaths) {
+            handles.push(await resolved.acquireLock(lockPath, {
+                purpose: "wallet-reset",
+                walletRootId: null,
+            }));
+        }
+        return handles;
+    }
+    catch (error) {
+        await Promise.all(handles.map(async (handle) => handle.release().catch(() => undefined)));
+        throw error;
+    }
+}

package/dist/wallet/reset/types.d.ts

@@ -0,0 +1,189 @@
+import { type FileLockHandle } from "../fs/lock.js";
+import type { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import type { createRpcClient } from "../../bitcoind/node.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { WalletSecretProvider } from "../state/provider.js";
+import type { RawWalletStateEnvelope } from "../state/storage.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletPrompter } from "../lifecycle.js";
+export type WalletResetAction = "not-present" | "kept-unchanged" | "retain-mnemonic" | "deleted";
+export type WalletResetSecretCleanupStatus = "deleted" | "not-found" | "failed" | "unknown";
+export type WalletResetSnapshotResultStatus = "not-present" | "invalid-removed" | "deleted" | "preserved";
+export type WalletResetBitcoinDataDirResultStatus = "not-present" | "preserved" | "deleted" | "outside-reset-scope";
+export interface WalletResetResult {
+    dataRoot: string;
+    factoryResetReady: true;
+    stoppedProcesses: {
+        managedBitcoind: number;
+        indexerDaemon: number;
+        backgroundMining: number;
+        survivors: number;
+    };
+    secretCleanupStatus: WalletResetSecretCleanupStatus;
+    deletedSecretRefs: string[];
+    failedSecretRefs: string[];
+    preservedSecretRefs: string[];
+    walletAction: WalletResetAction;
+    walletOldRootId: string | null;
+    walletNewRootId: string | null;
+    bootstrapSnapshot: {
+        status: WalletResetSnapshotResultStatus;
+        path: string;
+    };
+    bitcoinDataDir: {
+        status: WalletResetBitcoinDataDirResultStatus;
+        path: string;
+    };
+    removedPaths: string[];
+}
+export interface WalletResetPreview {
+    dataRoot: string;
+    confirmationPhrase: "permanently reset";
+    walletPrompt: null | {
+        defaultAction: "retain-mnemonic";
+        acceptedInputs: ["", "skip", "clear wallet entropy"];
+        entropyRetainingResetAvailable: boolean;
+        envelopeSource: "primary" | "backup" | null;
+    };
+    bootstrapSnapshot: {
+        status: "not-present" | "invalid" | "valid";
+        path: string;
+        defaultAction: "preserve" | "delete";
+    };
+    bitcoinDataDir: {
+        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
+        path: string;
+        conditionalPrompt: null | {
+            prompt: "Delete managed Bitcoin datadir too? [y/N]: ";
+            defaultAction: "preserve";
+            acceptedInputs: ["", "n", "no", "y", "yes"];
+        };
+    };
+    trackedProcessKinds: Array<"managed-bitcoind" | "indexer-daemon" | "background-mining">;
+    willDeleteOsSecrets: boolean;
+    removedPaths: string[];
+}
+export type WalletEnvelopeMode = "provider-backed" | "unsupported-legacy" | "unknown";
+export interface WalletResetPreflight {
+    dataRoot: string;
+    removedRoots: string[];
+    wallet: {
+        present: boolean;
+        mode: WalletEnvelopeMode;
+        envelopeSource: "primary" | "backup" | null;
+        secretProviderKeyId: string | null;
+        importedSeedSecretProviderKeyIds: string[];
+        rawEnvelope: RawWalletStateEnvelope | null;
+    };
+    snapshot: {
+        status: "not-present" | "invalid" | "valid";
+        path: string;
+        shouldPrompt: boolean;
+        withinResetScope: boolean;
+    };
+    bitcoinDataDir: {
+        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
+        path: string;
+        shouldPrompt: boolean;
+    };
+    trackedProcesses: TrackedManagedProcess[];
+    trackedProcessKinds: Array<TrackedManagedProcess["kind"]>;
+    serviceLockPaths: string[];
+}
+export interface TrackedManagedProcess {
+    kind: "managed-bitcoind" | "indexer-daemon" | "background-mining";
+    pid: number;
+}
+export interface StagedArtifact {
+    originalPath: string;
+    stagedPath: string;
+    restorePath: string;
+}
+export interface WalletAccessForReset {
+    loaded: {
+        source: "primary" | "backup";
+        state: WalletStateV1;
+    };
+    access: {
+        kind: "provider";
+        provider: WalletSecretProvider;
+    };
+}
+export interface ResetWalletRpcClient {
+    getDescriptorInfo(descriptor: string): Promise<{
+        descriptor: string;
+        checksum: string;
+    }>;
+    createWallet(walletName: string, options: {
+        blank: boolean;
+        descriptors: boolean;
+        disablePrivateKeys: boolean;
+        loadOnStartup: boolean;
+        passphrase: string;
+    }): Promise<unknown>;
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
+    importDescriptors(walletName: string, requests: Array<{
+        desc: string;
+        timestamp: string | number;
+        active?: boolean;
+        internal?: boolean;
+        range?: number | [number, number];
+    }>): Promise<Array<{
+        success: boolean;
+    }>>;
+    walletLock(walletName: string): Promise<null>;
+    deriveAddresses(descriptor: string, range?: number | [number, number]): Promise<string[]>;
+    listDescriptors(walletName: string, privateOnly?: boolean): Promise<{
+        descriptors: Array<{
+            desc: string;
+        }>;
+    }>;
+    getWalletInfo(walletName: string): Promise<{
+        walletname: string;
+        private_keys_enabled: boolean;
+        descriptors: boolean;
+    }>;
+    loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
+        name: string;
+        warning: string;
+    }>;
+    listWallets(): Promise<string[]>;
+}
+export interface ResetExecutionDecision {
+    walletChoice: "" | "skip" | "clear wallet entropy";
+    deleteSnapshot: boolean;
+    deleteBitcoinDataDir: boolean;
+    loadedWalletForEntropyReset: WalletAccessForReset | null;
+}
+export interface WalletResetArtifactDependencies {
+    access?: typeof import("node:fs/promises").access;
+    copyFile?: typeof import("node:fs/promises").copyFile;
+    mkdir?: typeof import("node:fs/promises").mkdir;
+    readFile?: typeof import("node:fs/promises").readFile;
+    rename?: typeof import("node:fs/promises").rename;
+    remove?: typeof import("node:fs/promises").rm;
+}
+export interface WalletResetProcessCleanupDependencies {
+    acquireLock?: (path: string, metadata: {
+        purpose: string;
+        walletRootId: null;
+    }) => Promise<FileLockHandle>;
+    processKill?: typeof process.kill;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface WalletResetBaseOptions {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    paths?: WalletRuntimePaths;
+}
+export interface WalletResetPreflightOptions extends WalletResetBaseOptions {
+    validateSnapshotFile?: (path: string) => Promise<void>;
+    artifactDeps?: WalletResetArtifactDependencies;
+    processCleanupDeps?: WalletResetProcessCleanupDependencies;
+}
+export interface WalletResetExecutionOptions extends WalletResetPreflightOptions {
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => ResetWalletRpcClient;
+}

package/dist/wallet/reset/types.js

@@ -0,0 +1 @@
+import {} from "../fs/lock.js";

package/dist/wallet/reset.d.ts

@@ -1,119 +1,4 @@
-import { createRpcClient } from "../bitcoind/node.js";
-import { attachOrStartManagedBitcoindService } from "../bitcoind/service.js";
-import { type WalletRuntimePaths } from "./runtime.js";
-import { type WalletSecretProvider } from "./state/provider.js";
-import type { WalletPrompter } from "./lifecycle.js";
-export type WalletResetAction = "not-present" | "kept-unchanged" | "retain-mnemonic" | "deleted";
-export type WalletResetSecretCleanupStatus = "deleted" | "not-found" | "failed" | "unknown";
-export type WalletResetSnapshotResultStatus = "not-present" | "invalid-removed" | "deleted" | "preserved";
-export type WalletResetBitcoinDataDirResultStatus = "not-present" | "preserved" | "deleted" | "outside-reset-scope";
-export interface WalletResetResult {
-    dataRoot: string;
-    factoryResetReady: true;
-    stoppedProcesses: {
-        managedBitcoind: number;
-        indexerDaemon: number;
-        backgroundMining: number;
-        survivors: number;
-    };
-    secretCleanupStatus: WalletResetSecretCleanupStatus;
-    deletedSecretRefs: string[];
-    failedSecretRefs: string[];
-    preservedSecretRefs: string[];
-    walletAction: WalletResetAction;
-    walletOldRootId: string | null;
-    walletNewRootId: string | null;
-    bootstrapSnapshot: {
-        status: WalletResetSnapshotResultStatus;
-        path: string;
-    };
-    bitcoinDataDir: {
-        status: WalletResetBitcoinDataDirResultStatus;
-        path: string;
-    };
-    removedPaths: string[];
-}
-export interface WalletResetPreview {
-    dataRoot: string;
-    confirmationPhrase: "permanently reset";
-    walletPrompt: null | {
-        defaultAction: "retain-mnemonic";
-        acceptedInputs: ["", "skip", "clear wallet entropy"];
-        entropyRetainingResetAvailable: boolean;
-        envelopeSource: "primary" | "backup" | null;
-    };
-    bootstrapSnapshot: {
-        status: "not-present" | "invalid" | "valid";
-        path: string;
-        defaultAction: "preserve" | "delete";
-    };
-    bitcoinDataDir: {
-        status: "not-present" | "within-reset-scope" | "outside-reset-scope";
-        path: string;
-        conditionalPrompt: null | {
-            prompt: "Delete managed Bitcoin datadir too? [y/N]: ";
-            defaultAction: "preserve";
-            acceptedInputs: ["", "n", "no", "y", "yes"];
-        };
-    };
-    trackedProcessKinds: Array<"managed-bitcoind" | "indexer-daemon" | "background-mining">;
-    willDeleteOsSecrets: boolean;
-    removedPaths: string[];
-}
-interface ResetWalletRpcClient {
-    getDescriptorInfo(descriptor: string): Promise<{
-        descriptor: string;
-        checksum: string;
-    }>;
-    createWallet(walletName: string, options: {
-        blank: boolean;
-        descriptors: boolean;
-        disablePrivateKeys: boolean;
-        loadOnStartup: boolean;
-        passphrase: string;
-    }): Promise<unknown>;
-    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
-    importDescriptors(walletName: string, requests: Array<{
-        desc: string;
-        timestamp: string | number;
-        active?: boolean;
-        internal?: boolean;
-        range?: number | [number, number];
-    }>): Promise<Array<{
-        success: boolean;
-    }>>;
-    walletLock(walletName: string): Promise<null>;
-    deriveAddresses(descriptor: string, range?: number | [number, number]): Promise<string[]>;
-    listDescriptors(walletName: string, privateOnly?: boolean): Promise<{
-        descriptors: Array<{
-            desc: string;
-        }>;
-    }>;
-    getWalletInfo(walletName: string): Promise<{
-        walletname: string;
-        private_keys_enabled: boolean;
-        descriptors: boolean;
-    }>;
-    loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
-        name: string;
-        warning: string;
-    }>;
-    listWallets(): Promise<string[]>;
-}
-export declare function previewResetWallet(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    paths?: WalletRuntimePaths;
-    validateSnapshotFile?: (path: string) => Promise<void>;
-}): Promise<WalletResetPreview>;
-export declare function resetWallet(options: {
-    dataDir: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    validateSnapshotFile?: (path: string) => Promise<void>;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => ResetWalletRpcClient;
-}): Promise<WalletResetResult>;
-export {};
+export type { WalletResetAction, WalletResetBitcoinDataDirResultStatus, WalletResetPreview, WalletResetResult, WalletResetSecretCleanupStatus, WalletResetSnapshotResultStatus, } from "./reset/types.js";
+import type { WalletResetExecutionOptions, WalletResetPreflightOptions, WalletResetPreview, WalletResetResult } from "./reset/types.js";
+export declare function previewResetWallet(options: WalletResetPreflightOptions): Promise<WalletResetPreview>;
+export declare function resetWallet(options: WalletResetExecutionOptions): Promise<WalletResetResult>;