@cogcoin/client 0.5.14 → 1.0.0

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

@@ -1,11 +1,14 @@
-import { parseUnlockDurationToMs } from "../../wallet/lifecycle.js";
-import { buildInitMutationData, buildResetMutationData, buildRestoreMutationData, buildWalletDeleteMutationData, buildUnlockMutationData, buildRepairMutationData, buildWalletExportMutationData, buildWalletImportMutationData, buildWalletLockMutationData, } from "../mutation-json.js";
-import { buildResetPreviewData, buildRepairPreviewData, buildWalletLockPreviewData, } from "../preview-json.js";
+import { buildInitMutationData, buildResetMutationData, buildRestoreMutationData, buildWalletDeleteMutationData, buildRepairMutationData, } from "../mutation-json.js";
+import { buildResetPreviewData, buildRepairPreviewData, } from "../preview-json.js";
 import { writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMutationJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
-import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getRestoreNextSteps, } from "../workflow-hints.js";
+import { loadWelcomeArtText } from "../art.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getRestoreNextSteps, getSetupUnlockGuidanceLines, } from "../workflow-hints.js";
 import { createOwnedLockCleanupSignalWatcher, waitForCompletionOrStop, } from "../signals.js";
+import { runSyncCommand } from "./sync.js";
+import { CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS } from "../../wallet/state/client-password.js";
+import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function createCommandPrompter(parsed, context) {
     return parsed.outputMode !== "text"
         ? createTerminalPrompter(context.stdin, context.stderr)
@@ -21,24 +24,32 @@ function getResetWarnings(result) {
         ? ["Some existing Cogcoin secret-provider entries could not be discovered from the remaining local wallet artifacts and may need manual cleanup."]
         : [];
 }
+function writeSetupUnlockGuidance(stdout) {
+    for (const line of getSetupUnlockGuidanceLines(CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS)) {
+        writeLine(stdout, line);
+    }
+}
 function getResetNextSteps(result) {
     return result.walletAction === "deleted" || result.walletAction === "not-present"
         ? ["Run `cogcoin init` to create a new wallet."]
         : ["Run `cogcoin sync` to bootstrap assumeutxo and the managed Bitcoin/indexer state."];
 }
+function getRepairNextSteps() {
+    return ["Run `cogcoin status` to review the repaired local state."];
+}
 function formatResetBitcoinDataDirStatus(result) {
     if (result.bitcoinDataDir.status === "outside-reset-scope") {
         return "preserved (outside reset scope)";
     }
     return result.bitcoinDataDir.status;
 }
-function resetTextEntry(label, value, ok) {
+function sectionTextEntry(label, value, ok) {
     return {
         text: `${label}: ${value}`,
         ok,
     };
 }
-function formatResetSection(header, entries) {
+function formatAdminSection(header, entries) {
     return [header, ...entries.map((entry) => `${entry.ok ? "✓" : "✗"} ${entry.text}`)].join("\n");
 }
 function formatResetResultText(result) {
@@ -47,30 +58,30 @@ function formatResetResultText(result) {
     const secretCleanupOk = result.secretCleanupStatus !== "unknown" && result.secretCleanupStatus !== "failed";
     const managedCleanupOk = result.stoppedProcesses.survivors === 0;
     const outcomeEntries = [
-        resetTextEntry("Wallet action", result.walletAction, true),
-        resetTextEntry("Snapshot", result.bootstrapSnapshot.status, true),
-        resetTextEntry("Bitcoin datadir", formatResetBitcoinDataDirStatus(result), true),
-        resetTextEntry("Secret cleanup", result.secretCleanupStatus, secretCleanupOk),
+        sectionTextEntry("Wallet action", result.walletAction, true),
+        sectionTextEntry("Snapshot", result.bootstrapSnapshot.status, true),
+        sectionTextEntry("Bitcoin datadir", formatResetBitcoinDataDirStatus(result), true),
+        sectionTextEntry("Secret cleanup", result.secretCleanupStatus, secretCleanupOk),
     ];
     if (result.walletAction !== "retain-mnemonic" && result.walletOldRootId !== null) {
-        outcomeEntries.push(resetTextEntry("Previous wallet root", result.walletOldRootId, true));
+        outcomeEntries.push(sectionTextEntry("Previous wallet root", result.walletOldRootId, true));
     }
     if (result.walletAction !== "retain-mnemonic" && result.walletNewRootId !== null) {
-        outcomeEntries.push(resetTextEntry("New wallet root", result.walletNewRootId, true));
+        outcomeEntries.push(sectionTextEntry("New wallet root", result.walletNewRootId, true));
     }
     const sections = [
-        formatResetSection("Paths", [
-            resetTextEntry("Data root", result.dataRoot, true),
+        formatAdminSection("Paths", [
+            sectionTextEntry("Data root", result.dataRoot, true),
         ]),
-        formatResetSection("Reset Outcome", outcomeEntries),
-        formatResetSection("Managed Cleanup", [
-            resetTextEntry("Managed bitcoind processes stopped", String(result.stoppedProcesses.managedBitcoind), managedCleanupOk),
-            resetTextEntry("Indexer daemons stopped", String(result.stoppedProcesses.indexerDaemon), managedCleanupOk),
-            resetTextEntry("Background miners stopped", String(result.stoppedProcesses.backgroundMining), managedCleanupOk),
+        formatAdminSection("Reset Outcome", outcomeEntries),
+        formatAdminSection("Managed Cleanup", [
+            sectionTextEntry("Managed bitcoind processes stopped", String(result.stoppedProcesses.managedBitcoind), managedCleanupOk),
+            sectionTextEntry("Indexer daemons stopped", String(result.stoppedProcesses.indexerDaemon), managedCleanupOk),
+            sectionTextEntry("Background miners stopped", String(result.stoppedProcesses.backgroundMining), managedCleanupOk),
         ]),
     ];
     if (warnings.length > 0) {
-        sections.push(formatResetSection("Warnings", warnings.map((warning) => resetTextEntry("Warning", warning, false))));
+        sections.push(formatAdminSection("Warnings", warnings.map((warning) => sectionTextEntry("Warning", warning, false))));
     }
     const parts = [
         "\n⛭ Cogcoin Reset ⛭",
@@ -81,6 +92,68 @@ function formatResetResultText(result) {
     }
     return parts.join("\n\n");
 }
+function isRepairMiningResumeActionOk(action) {
+    return action === "none"
+        || action === "skipped-not-resumable"
+        || action === "resumed-background";
+}
+function buildRepairWarningEntries(result) {
+    const entries = [];
+    if (result.miningResumeError !== null) {
+        entries.push(sectionTextEntry("Mining resume error", result.miningResumeError, false));
+    }
+    for (const warning of getRepairWarnings(result)) {
+        if (result.miningResumeError !== null && warning.includes(result.miningResumeError)) {
+            continue;
+        }
+        entries.push(sectionTextEntry("Warning", warning, false));
+    }
+    return entries;
+}
+function formatRepairResultText(result) {
+    const nextStep = getRepairNextSteps()[0] ?? null;
+    const warningEntries = buildRepairWarningEntries(result);
+    const sections = [
+        formatAdminSection("Wallet", [
+            sectionTextEntry("Wallet root", result.walletRootId, true),
+            sectionTextEntry("Recovered from backup", result.recoveredFromBackup ? "yes" : "no", true),
+            sectionTextEntry("Managed Core wallet recreated", result.recreatedManagedCoreWallet ? "yes" : "no", true),
+        ]),
+        formatAdminSection("Managed Bitcoind", [
+            sectionTextEntry("Managed bitcoind action", result.bitcoindServiceAction, true),
+            sectionTextEntry("Managed bitcoind compatibility issue", result.bitcoindCompatibilityIssue, result.bitcoindCompatibilityIssue === "none"),
+            sectionTextEntry("Managed Core replica action", result.managedCoreReplicaAction, true),
+            sectionTextEntry("Managed bitcoind post-repair health", result.bitcoindPostRepairHealth, result.bitcoindPostRepairHealth === "ready"),
+        ]),
+        formatAdminSection("Indexer", [
+            sectionTextEntry("Indexer database reset", result.resetIndexerDatabase ? "yes" : "no", true),
+            sectionTextEntry("Indexer daemon action", result.indexerDaemonAction, true),
+            sectionTextEntry("Indexer compatibility issue", result.indexerCompatibilityIssue, result.indexerCompatibilityIssue === "none"),
+            sectionTextEntry("Indexer post-repair health", result.indexerPostRepairHealth, result.indexerPostRepairHealth === "synced"),
+        ]),
+        formatAdminSection("Mining", [
+            sectionTextEntry("Mining mode before repair", result.miningPreRepairRunMode, true),
+            sectionTextEntry("Mining resume action", result.miningResumeAction, isRepairMiningResumeActionOk(result.miningResumeAction)),
+            sectionTextEntry("Mining mode after repair", result.miningPostRepairRunMode, true),
+        ]),
+    ];
+    if (result.note !== null) {
+        sections.push(formatAdminSection("Notes", [
+            sectionTextEntry("Note", result.note, true),
+        ]));
+    }
+    if (warningEntries.length > 0) {
+        sections.push(formatAdminSection("Warnings", warningEntries));
+    }
+    const parts = [
+        "\n⛭ Cogcoin Repair ⛭",
+        ...sections,
+    ];
+    if (nextStep !== null) {
+        parts.push(`Next step: ${nextStep}`);
+    }
+    return parts.join("\n\n");
+}
 export async function runWalletAdminCommand(parsed, context) {
     const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
     const stopWatcher = createOwnedLockCleanupSignalWatcher(context.signalSource, context.forceExit, [
@@ -89,15 +162,17 @@ export async function runWalletAdminCommand(parsed, context) {
         runtimePaths.bitcoindLockPath,
         runtimePaths.indexerDaemonLockPath,
     ]);
+    let shouldAutoSyncAfterInit = false;
     try {
         const outcome = await waitForCompletionOrStop((async () => {
             const provider = context.walletSecretProvider;
             if (parsed.command === "init" || parsed.command === "wallet-init") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.initializeWallet({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     paths: runtimePaths,
                 });
@@ -109,22 +184,42 @@ export async function runWalletAdminCommand(parsed, context) {
                     }));
                     return 0;
                 }
-                writeLine(context.stdout, `Wallet initialized.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                writeLine(context.stdout, `Quickstart: ${getFundingQuickstartGuidance()}`);
-                for (const line of formatNextStepLines(nextSteps)) {
-                    writeLine(context.stdout, line);
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, loadWelcomeArtText());
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, result.walletAction === "already-initialized"
+                    ? "Wallet already initialized."
+                    : "Wallet initialized.");
+                if (result.walletAction === "already-initialized") {
+                    writeLine(context.stdout, "");
+                    writeLine(context.stdout, "Wallet");
+                    writeLine(context.stdout, `✓ Client password: ${result.passwordAction}`);
+                    writeLine(context.stdout, `✓ Wallet root: ${result.walletRootId}`);
+                    writeLine(context.stdout, `✓ Funding address: ${result.fundingAddress}`);
+                    if (result.passwordAction !== "already-configured") {
+                        writeSetupUnlockGuidance(context.stdout);
+                    }
+                }
+                else {
+                    writeLine(context.stdout, `Client password: ${result.passwordAction}`);
+                    if (result.passwordAction !== "already-configured") {
+                        writeSetupUnlockGuidance(context.stdout);
+                    }
+                    writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+                    writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
                 }
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, `Quickstart: ${getFundingQuickstartGuidance()}`);
+                shouldAutoSyncAfterInit = true;
                 return 0;
             }
             if (parsed.command === "restore" || parsed.command === "wallet-restore") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.restoreWalletFromMnemonic({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     paths: runtimePaths,
                 });
@@ -139,9 +234,11 @@ export async function runWalletAdminCommand(parsed, context) {
                     return 0;
                 }
                 writeLine(context.stdout, `Wallet seed "${result.seedName}" restored from mnemonic.`);
+                if (result.passwordAction !== "already-configured") {
+                    writeSetupUnlockGuidance(context.stdout);
+                }
                 writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
                 writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
                 writeLine(context.stdout, "Note: Managed Bitcoin/indexer bootstrap is deferred until you run `cogcoin sync`.");
                 for (const warning of result.warnings ?? []) {
                     writeLine(context.stdout, `Warning: ${warning}`);
@@ -154,9 +251,10 @@ export async function runWalletAdminCommand(parsed, context) {
             if (parsed.command === "wallet-delete") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.deleteImportedWalletSeed({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
                     paths: runtimePaths,
@@ -172,29 +270,13 @@ export async function runWalletAdminCommand(parsed, context) {
             if (parsed.command === "wallet-show-mnemonic") {
                 const prompter = createCommandPrompter(parsed, context);
                 await context.showWalletMnemonic({
-                    provider,
+                    provider: withInteractiveWalletSecretProvider(provider, prompter),
                     prompter,
                     paths: runtimePaths,
                 });
                 return 0;
             }
             const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
-            if (parsed.command === "unlock" || parsed.command === "wallet-unlock") {
-                const durationMs = parseUnlockDurationToMs(parsed.unlockFor);
-                const result = await context.unlockWallet({
-                    provider,
-                    unlockDurationMs: durationMs,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "unlocked", buildUnlockMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet unlocked.`);
-                writeLine(context.stdout, `Wallet root: ${result.state.walletRootId}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                return 0;
-            }
             if (parsed.command === "reset") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 if (parsed.outputMode === "preview-json") {
@@ -208,7 +290,7 @@ export async function runWalletAdminCommand(parsed, context) {
                 const prompter = createCommandPrompter(parsed, context);
                 const result = await context.resetWallet({
                     dataDir,
-                    provider,
+                    provider: withInteractiveWalletSecretProvider(provider, prompter),
                     prompter,
                 });
                 if (parsed.outputMode === "json") {
@@ -221,113 +303,33 @@ export async function runWalletAdminCommand(parsed, context) {
                 writeLine(context.stdout, formatResetResultText(result));
                 return 0;
             }
-            if (parsed.command === "wallet-export") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const prompter = createCommandPrompter(parsed, context);
-                const result = await context.exportWallet({
-                    archivePath: parsed.args[0],
-                    dataDir,
-                    databasePath: dbPath,
-                    provider,
-                    prompter,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "exported", buildWalletExportMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet exported.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Archive path: ${result.archivePath}`);
-                return 0;
-            }
-            if (parsed.command === "wallet-import") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const prompter = createCommandPrompter(parsed, context);
-                const result = await context.importWallet({
-                    archivePath: parsed.args[0],
-                    dataDir,
-                    databasePath: dbPath,
-                    provider,
-                    prompter,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "imported", buildWalletImportMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet imported.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                return 0;
-            }
-            if (parsed.command === "wallet-lock") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const result = await context.lockWallet({
-                    dataDir,
-                    provider,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "preview-json") {
-                    writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "locked", buildWalletLockPreviewData(result)));
-                    return 0;
-                }
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin wallet lock", "locked", buildWalletLockMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet locked.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId ?? "none"}`);
-                return 0;
-            }
             if (parsed.command === "repair") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+                const repairProvider = parsed.outputMode === "preview-json"
+                    ? provider
+                    : withInteractiveWalletSecretProvider(provider, createCommandPrompter(parsed, context));
                 const result = await context.repairWallet({
                     dataDir,
                     databasePath: dbPath,
-                    provider,
+                    provider: repairProvider,
                     assumeYes: parsed.assumeYes,
                     paths: runtimePaths,
                 });
                 if (parsed.outputMode === "preview-json") {
                     writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "completed", buildRepairPreviewData(result), {
-                        nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                        nextSteps: getRepairNextSteps(),
                         warnings: getRepairWarnings(result),
                     }));
                     return 0;
                 }
                 if (parsed.outputMode === "json") {
                     writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin repair", "completed", buildRepairMutationData(result), {
-                        nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                        nextSteps: getRepairNextSteps(),
                         warnings: getRepairWarnings(result),
                     }));
                     return 0;
                 }
-                writeLine(context.stdout, `Wallet repair completed.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Recovered from backup: ${result.recoveredFromBackup ? "yes" : "no"}`);
-                writeLine(context.stdout, `Managed Core wallet recreated: ${result.recreatedManagedCoreWallet ? "yes" : "no"}`);
-                writeLine(context.stdout, `Managed bitcoind action: ${result.bitcoindServiceAction}`);
-                writeLine(context.stdout, `Managed bitcoind compatibility issue: ${result.bitcoindCompatibilityIssue}`);
-                writeLine(context.stdout, `Managed Core replica action: ${result.managedCoreReplicaAction}`);
-                writeLine(context.stdout, `Managed bitcoind post-repair health: ${result.bitcoindPostRepairHealth}`);
-                writeLine(context.stdout, `Indexer database reset: ${result.resetIndexerDatabase ? "yes" : "no"}`);
-                writeLine(context.stdout, `Indexer daemon action: ${result.indexerDaemonAction}`);
-                writeLine(context.stdout, `Indexer compatibility issue: ${result.indexerCompatibilityIssue}`);
-                writeLine(context.stdout, `Indexer post-repair health: ${result.indexerPostRepairHealth}`);
-                writeLine(context.stdout, `Mining mode before repair: ${result.miningPreRepairRunMode}`);
-                writeLine(context.stdout, `Mining resume action: ${result.miningResumeAction}`);
-                writeLine(context.stdout, `Mining mode after repair: ${result.miningPostRepairRunMode}`);
-                if (result.miningResumeError !== null) {
-                    writeLine(context.stdout, `Mining resume error: ${result.miningResumeError}`);
-                }
-                if (result.note !== null) {
-                    writeLine(context.stdout, `Note: ${result.note}`);
-                }
-                for (const warning of getRepairWarnings(result)) {
-                    writeLine(context.stdout, `Warning: ${warning}`);
-                }
+                writeLine(context.stdout, formatRepairResultText(result));
                 return 0;
             }
             writeLine(context.stderr, `wallet admin command not implemented: ${parsed.command}`);
@@ -336,6 +338,10 @@ export async function runWalletAdminCommand(parsed, context) {
         if (outcome.kind === "stopped") {
             return outcome.code;
         }
+        if (shouldAutoSyncAfterInit && outcome.value === 0) {
+            stopWatcher.cleanup();
+            return await runSyncCommand(parsed, context);
+        }
         return outcome.value;
     }
     catch (error) {