@cogcoin/client 1.0.1 → 1.1.0

package/dist/cli/update-service.js

@@ -0,0 +1,152 @@
+import { readFile } from "node:fs/promises";
+import { compareSemver, parseSemver, } from "../semver.js";
+import { writeJsonFileAtomic } from "../wallet/fs/atomic.js";
+export const UPDATE_CHECK_CACHE_SCHEMA_VERSION = 1;
+export const UPDATE_CHECK_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const PASSIVE_UPDATE_CHECK_TIMEOUT_MS = 500;
+export const EXPLICIT_UPDATE_CHECK_TIMEOUT_MS = 5_000;
+export const UPDATE_CHECK_URL = "https://registry.npmjs.org/@cogcoin/client/latest";
+export const CLI_INSTALL_COMMAND = "npm install -g @cogcoin/client";
+export function createEmptyUpdateCheckCache() {
+    return {
+        schemaVersion: UPDATE_CHECK_CACHE_SCHEMA_VERSION,
+        lastCheckedAtUnixMs: 0,
+        latestVersion: null,
+        lastNotifiedCurrentVersion: null,
+        lastNotifiedLatestVersion: null,
+        lastNotifiedAtUnixMs: null,
+    };
+}
+export { compareSemver, parseSemver };
+export function isUpdateCheckDisabled(env) {
+    const raw = env.COGCOIN_DISABLE_UPDATE_CHECK;
+    if (raw === undefined) {
+        return false;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function normalizeUpdateCheckCache(parsed) {
+    if (typeof parsed !== "object" || parsed === null) {
+        return null;
+    }
+    const candidate = parsed;
+    if (candidate.schemaVersion !== UPDATE_CHECK_CACHE_SCHEMA_VERSION) {
+        return null;
+    }
+    return {
+        schemaVersion: UPDATE_CHECK_CACHE_SCHEMA_VERSION,
+        lastCheckedAtUnixMs: typeof candidate.lastCheckedAtUnixMs === "number" ? candidate.lastCheckedAtUnixMs : 0,
+        latestVersion: typeof candidate.latestVersion === "string" ? candidate.latestVersion : null,
+        lastNotifiedCurrentVersion: typeof candidate.lastNotifiedCurrentVersion === "string"
+            ? candidate.lastNotifiedCurrentVersion
+            : null,
+        lastNotifiedLatestVersion: typeof candidate.lastNotifiedLatestVersion === "string"
+            ? candidate.lastNotifiedLatestVersion
+            : null,
+        lastNotifiedAtUnixMs: typeof candidate.lastNotifiedAtUnixMs === "number"
+            ? candidate.lastNotifiedAtUnixMs
+            : null,
+        lastCheckErrorKind: typeof candidate.lastCheckErrorKind === "string"
+            ? candidate.lastCheckErrorKind
+            : undefined,
+    };
+}
+export async function loadUpdateCheckCache(cachePath) {
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        return normalizeUpdateCheckCache(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+export function shouldRefreshUpdateCheck(cache, now) {
+    return now - cache.lastCheckedAtUnixMs >= UPDATE_CHECK_MAX_AGE_MS;
+}
+export function applyUpdateCheckResult(cache, result, now) {
+    return {
+        ...cache,
+        lastCheckedAtUnixMs: now,
+        latestVersion: result.kind === "success" ? result.latestVersion : cache.latestVersion,
+        lastCheckErrorKind: result.kind === "success" ? undefined : result.errorKind,
+    };
+}
+export function recordUpdateNotification(cache, currentVersion, latestVersion, now) {
+    return {
+        ...cache,
+        lastNotifiedCurrentVersion: currentVersion,
+        lastNotifiedLatestVersion: latestVersion,
+        lastNotifiedAtUnixMs: now,
+    };
+}
+export async function fetchLatestPublishedVersion(fetchImpl, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort();
+    }, options.timeoutMs ?? PASSIVE_UPDATE_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(UPDATE_CHECK_URL, {
+            headers: {
+                accept: "application/json",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return {
+                kind: "failure",
+                errorKind: `http_${response.status}`,
+            };
+        }
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            return {
+                kind: "failure",
+                errorKind: "invalid_json",
+            };
+        }
+        const latestVersion = typeof payload.version === "string"
+            ? payload.version
+            : null;
+        if (latestVersion === null) {
+            return {
+                kind: "failure",
+                errorKind: "invalid_payload",
+            };
+        }
+        if (parseSemver(latestVersion) === null) {
+            return {
+                kind: "failure",
+                errorKind: "invalid_semver",
+            };
+        }
+        return {
+            kind: "success",
+            latestVersion,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return {
+                kind: "failure",
+                errorKind: "timeout",
+            };
+        }
+        return {
+            kind: "failure",
+            errorKind: "network",
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function persistUpdateCheckCache(cachePath, cache) {
+    await writeJsonFileAtomic(cachePath, cache);
+}

package/dist/client/initialization.js

@@ -22,6 +22,9 @@ export async function initializeState(store, genesisParameters) {
         if (tip !== null) {
             throw new Error("client_store_tip_without_snapshot");
         }
+        // Repair orphaned rewind rows from previously interrupted writers so the
+        // next replay pass does not collide on a stale future height.
+        await store.deleteBlockRecordsAbove(-1);
         return {
             state: createInitialState(genesisParameters),
             tip: null,
@@ -36,6 +39,7 @@ export async function initializeState(store, genesisParameters) {
         };
     }
     if (tip === null) {
+        await store.deleteBlockRecordsAbove(snapshot.height);
         return {
             state,
             tip: {
@@ -49,5 +53,6 @@ export async function initializeState(store, genesisParameters) {
     if (tip.height !== snapshot.height || tip.blockHashHex !== snapshot.blockHashHex) {
         throw new Error("client_store_snapshot_tip_mismatch");
     }
+    await store.deleteBlockRecordsAbove(tip.height);
     return { state, tip };
 }

package/dist/semver.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedSemver {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: Array<{
+        raw: string;
+        numeric: boolean;
+        numericValue: number | null;
+    }>;
+}
+export declare function parseSemver(version: string): ParsedSemver | null;
+export declare function compareSemver(left: string, right: string): number | null;

package/dist/semver.js

@@ -0,0 +1,68 @@
+export function parseSemver(version) {
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version.trim());
+    if (match === null) {
+        return null;
+    }
+    const prerelease = match[4] === undefined
+        ? []
+        : match[4].split(".").map((raw) => ({
+            raw,
+            numeric: /^(0|[1-9]\d*)$/.test(raw),
+            numericValue: /^(0|[1-9]\d*)$/.test(raw) ? Number(raw) : null,
+        }));
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease,
+    };
+}
+export function compareSemver(left, right) {
+    const leftParsed = parseSemver(left);
+    const rightParsed = parseSemver(right);
+    if (leftParsed === null || rightParsed === null) {
+        return null;
+    }
+    if (leftParsed.major !== rightParsed.major) {
+        return leftParsed.major > rightParsed.major ? 1 : -1;
+    }
+    if (leftParsed.minor !== rightParsed.minor) {
+        return leftParsed.minor > rightParsed.minor ? 1 : -1;
+    }
+    if (leftParsed.patch !== rightParsed.patch) {
+        return leftParsed.patch > rightParsed.patch ? 1 : -1;
+    }
+    if (leftParsed.prerelease.length === 0 && rightParsed.prerelease.length === 0) {
+        return 0;
+    }
+    if (leftParsed.prerelease.length === 0) {
+        return 1;
+    }
+    if (rightParsed.prerelease.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(leftParsed.prerelease.length, rightParsed.prerelease.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftIdentifier = leftParsed.prerelease[index];
+        const rightIdentifier = rightParsed.prerelease[index];
+        if (leftIdentifier === undefined) {
+            return -1;
+        }
+        if (rightIdentifier === undefined) {
+            return 1;
+        }
+        if (leftIdentifier.numeric && rightIdentifier.numeric) {
+            if (leftIdentifier.numericValue !== rightIdentifier.numericValue) {
+                return leftIdentifier.numericValue > rightIdentifier.numericValue ? 1 : -1;
+            }
+            continue;
+        }
+        if (leftIdentifier.numeric !== rightIdentifier.numeric) {
+            return leftIdentifier.numeric ? -1 : 1;
+        }
+        if (leftIdentifier.raw !== rightIdentifier.raw) {
+            return leftIdentifier.raw > rightIdentifier.raw ? 1 : -1;
+        }
+    }
+    return 0;
+}

package/dist/wallet/lifecycle.d.ts

@@ -10,6 +10,16 @@ export interface WalletPrompter {
     writeLine(message: string): void;
     prompt(message: string): Promise<string>;
     promptHidden?(message: string): Promise<string>;
+    selectOption?(options: {
+        message: string;
+        options: Array<{
+            label: string;
+            description?: string | null;
+            value: string;
+        }>;
+        initialValue?: string | null;
+        footer?: string | null;
+    }): Promise<string>;
     clearSensitiveDisplay?(scope: "mnemonic-reveal" | "restore-mnemonic-entry"): void | Promise<void>;
 }
 export interface WalletInitializationResult {

package/dist/wallet/mining/config.js

@@ -1,18 +1,74 @@
 import { readFile } from "node:fs/promises";
 import { writeJsonFileAtomic } from "../fs/atomic.js";
 import { decryptJsonWithSecretProvider, encryptJsonWithSecretProvider } from "../state/crypto.js";
+import { normalizeMiningProviderConfigRecord } from "./provider-model.js";
+const MINING_PROVIDER_KINDS = ["openai", "anthropic"];
+function normalizeDomainExtraPrompts(raw) {
+    if (raw === null || typeof raw !== "object") {
+        return {};
+    }
+    const normalized = new Map();
+    for (const [rawDomainName, rawPrompt] of Object.entries(raw)) {
+        if (typeof rawPrompt !== "string") {
+            continue;
+        }
+        const domainName = rawDomainName.trim().toLowerCase();
+        const prompt = rawPrompt.trim();
+        if (domainName.length === 0 || prompt.length === 0) {
+            continue;
+        }
+        normalized.set(domainName, prompt);
+    }
+    return Object.fromEntries([...normalized.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
 function createEmptyClientConfig() {
     return {
         schemaVersion: 1,
         mining: {
             builtIn: null,
+            domainExtraPrompts: {},
+        },
+    };
+}
+function normalizeBuiltInProviderConfigMap(raw) {
+    if (raw === null || typeof raw !== "object") {
+        return {};
+    }
+    const normalized = {};
+    const entries = raw;
+    for (const provider of MINING_PROVIDER_KINDS) {
+        const config = entries[provider];
+        if (config == null) {
+            continue;
+        }
+        normalized[provider] = normalizeMiningProviderConfigRecord({
+            ...config,
+            provider,
+        });
+    }
+    return normalized;
+}
+function normalizeClientConfig(config) {
+    const mining = config.mining ?? createEmptyClientConfig().mining;
+    const builtIn = mining.builtIn === null ? null : normalizeMiningProviderConfigRecord(mining.builtIn);
+    const builtInByProvider = normalizeBuiltInProviderConfigMap(mining.builtInByProvider);
+    if (builtIn !== null) {
+        builtInByProvider[builtIn.provider] = builtIn;
+    }
+    return {
+        ...config,
+        mining: {
+            ...mining,
+            builtIn,
+            ...(Object.keys(builtInByProvider).length === 0 ? {} : { builtInByProvider }),
+            domainExtraPrompts: normalizeDomainExtraPrompts(mining.domainExtraPrompts),
         },
     };
 }
 export async function loadClientConfig(options) {
     try {
         const raw = await readFile(options.path, "utf8");
-        return await decryptJsonWithSecretProvider(JSON.parse(raw), options.provider);
+        return normalizeClientConfig(await decryptJsonWithSecretProvider(JSON.parse(raw), options.provider));
     }
     catch (error) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -22,7 +78,7 @@ export async function loadClientConfig(options) {
     }
 }
 export async function saveClientConfig(options) {
-    const envelope = await encryptJsonWithSecretProvider(options.config, options.provider, options.secretReference, {
+    const envelope = await encryptJsonWithSecretProvider(normalizeClientConfig(options.config), options.provider, options.secretReference, {
         format: "cogcoin-client-config",
     });
     await writeJsonFileAtomic(options.path, envelope, { mode: 0o600 });
@@ -33,7 +89,12 @@ export async function saveBuiltInMiningProviderConfig(options) {
         provider: options.provider,
     }).catch(() => null);
     const nextConfig = existing ?? createEmptyClientConfig();
-    nextConfig.mining.builtIn = options.config;
+    const normalizedConfig = normalizeMiningProviderConfigRecord(options.config);
+    nextConfig.mining.builtIn = normalizedConfig;
+    nextConfig.mining.builtInByProvider = {
+        ...(nextConfig.mining.builtInByProvider ?? {}),
+        [normalizedConfig.provider]: normalizedConfig,
+    };
     await saveClientConfig({
         path: options.path,
         provider: options.provider,

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

@@ -2,7 +2,7 @@ import type { WalletPrompter } from "../lifecycle.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletBitcoindStatus, WalletIndexerStatus, WalletLocalStateStatus, WalletNodeStatus } from "../read/types.js";
-import type { MiningControlPlaneView, MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
+import type { MiningControlPlaneView, MiningEventRecord, MiningProviderConfigByProvider, MiningProviderConfigRecord, MiningRuntimeStatusV1 } from "./types.js";
 export declare function inspectMiningControlPlane(options: {
     provider?: WalletSecretProvider;
     localState: WalletLocalStateStatus;
@@ -23,6 +23,10 @@ export declare function refreshMiningRuntimeStatus(options: {
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
 }): Promise<MiningControlPlaneView>;
+export declare function promptForMiningProviderConfigForTesting(prompter: WalletPrompter, eligibleRootCount: number, options?: {
+    currentConfig?: MiningProviderConfigRecord | null;
+    rememberedConfigs?: MiningProviderConfigByProvider;
+}): Promise<MiningProviderConfigRecord>;
 export declare function setupBuiltInMining(options: {
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;