@routstr/cocod 0.0.17 → 0.0.18

package/README.md

@@ -66,6 +66,9 @@ cocod history --watch
 cocod logs
 cocod logs --follow
 cocod logs --path
+
+# Debug a stuck init/unlock in another terminal
+cocod logs --follow
 ```
 
 ## NPC (Lightning Address)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routstr/cocod",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "module": "src/index.ts",
   "type": "module",
   "private": false,

package/src/cli-shared.ts

@@ -42,8 +42,10 @@ export async function isDaemonRunning(): Promise<boolean> {
   }
 }
 
-const DAEMON_POLL_INTERVAL_MS = 100;
+const DAEMON_POLL_INTERVAL_MS = 1_000;
 const DAEMON_SLOW_START_WARNING_MS = 30_000;
+const DAEMON_START_TIMEOUT_MS = 60_000;
+const DAEMON_START_LOG_LINES = 40;
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -54,24 +56,50 @@ async function waitForDaemonReady(startedAt: number, warningShown: { value: bool
     try {
       const result = await callDaemon("/status");
       if (typeof result.output === "string") {
-        const status = result.output;
-        if (status === "LOCKED" || status === "UNLOCKED" || status === "ERROR") {
-          return;
-        }
+        return;
       }
     } catch {
       // Daemon may not be accepting requests yet
     }
 
-    if (!warningShown.value && Date.now() - startedAt >= DAEMON_SLOW_START_WARNING_MS) {
+    const elapsedMs = Date.now() - startedAt;
+
+    if (!warningShown.value && elapsedMs >= DAEMON_SLOW_START_WARNING_MS) {
       warningShown.value = true;
       console.log("Daemon is taking longer than expected, please wait...");
     }
 
+    if (elapsedMs >= DAEMON_START_TIMEOUT_MS) {
+      throw new Error("Daemon failed to start after 1 minute");
+    }
+
     await sleep(DAEMON_POLL_INTERVAL_MS);
   }
 }
 
+function printProgressStep(message: string): void {
+  console.log(`• ${message}`);
+}
+
+function maybePrintFriendlyProgress(path: string, body?: object): void {
+  if (path === "/init") {
+    const mintUrl =
+      body && "mintUrl" in body && typeof body.mintUrl === "string"
+        ? body.mintUrl
+        : "https://mint.minibits.cash/Bitcoin";
+
+    printProgressStep("Preparing wallet...");
+    printProgressStep(`Connecting to mint: ${mintUrl}`);
+    printProgressStep("This can take a few seconds on first run.");
+    return;
+  }
+
+  if (path === "/unlock") {
+    printProgressStep("Unlocking wallet...");
+    printProgressStep("Reconnecting wallet services...");
+  }
+}
+
 export async function startDaemonProcess(): Promise<void> {
   const proc = Bun.spawn({
     cmd: ["bun", "run", `${import.meta.dir}/index.ts`, "daemon"],
@@ -91,9 +119,16 @@ export async function startDaemonProcess(): Promise<void> {
       return;
     }
 
-    if (!warningShown.value && Date.now() - startedAt >= DAEMON_SLOW_START_WARNING_MS) {
+    const elapsedMs = Date.now() - startedAt;
+
+    if (!warningShown.value && elapsedMs >= DAEMON_SLOW_START_WARNING_MS) {
       warningShown.value = true;
       console.log("Daemon is taking longer than expected, please wait...");
+      console.log(`Tip: run 'cocod logs --follow' or 'tail -n ${DAEMON_START_LOG_LINES} ~/.cocod/daemon.log' in another terminal.`);
+    }
+
+    if (elapsedMs >= DAEMON_START_TIMEOUT_MS) {
+      throw new Error("Daemon failed to start after 1 minute");
     }
   }
 }
@@ -113,6 +148,7 @@ export async function handleDaemonCommand(
 ): Promise<CommandResponse> {
   try {
     await ensureDaemonRunning();
+    maybePrintFriendlyProgress(path, options.body);
     const result = await callDaemon(path, options);
 
     if (result.error) {

package/src/daemon.ts

@@ -1,8 +1,8 @@
 import { mnemonicToSeedSync } from "@scure/bip39";
 import { closeSync, openSync, writeFileSync } from "node:fs";
-import { unlink } from "node:fs/promises";
+import { mkdir, unlink } from "node:fs/promises";
 import process from "node:process";
-import { CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.js";
+import { CONFIG_DIR, CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.js";
 import { createDaemonLogger, serializeError } from "./utils/logger.js";
 import { DaemonStateManager } from "./utils/state.js";
 import { initializeWallet } from "./utils/wallet.js";
@@ -23,6 +23,8 @@ async function isProcessAlive(pid: number): Promise<boolean> {
 }
 
 async function acquirePidLock(logger: ReturnType<typeof createDaemonLogger>): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+
   const pidFile = Bun.file(PID_FILE);
   if (await pidFile.exists()) {
     const existingPidText = (await pidFile.text()).trim();
@@ -74,7 +76,7 @@ async function acquirePidLock(logger: ReturnType<typeof createDaemonLogger>): Pr
 
 export async function startDaemon() {
   const stateManager = new DaemonStateManager();
-  const logger = createDaemonLogger();
+  const logger = createDaemonLogger({ mirrorToConsole: false });
 
   logger.info("daemon.start.requested", {
     pidFile: PID_FILE,

package/src/routes.ts

@@ -36,34 +36,50 @@ export function createRouteHandlers(
     },
     "/init": {
       POST: stateManager.requireUninitialized(async (req: Request) => {
+        const initLogger = logger?.child?.({ route: "/init" }) ?? logger;
+
         try {
+          initLogger?.info?.("wallet.init.started");
+
           const body = (await req.json()) as {
             mnemonic?: string;
             passphrase?: string;
             mintUrl?: string;
           };
 
+          initLogger?.info?.("wallet.init.request_parsed", {
+            encrypted: Boolean(body.passphrase),
+            hasMnemonic: Boolean(body.mnemonic),
+            mintUrl: body.mintUrl || "https://mint.minibits.cash/Bitcoin",
+          });
+
           let mnemonic: string;
           if (body.mnemonic) {
+            initLogger?.info?.("wallet.init.validating_mnemonic");
             if (!validateMnemonic(body.mnemonic, wordlist)) {
+              initLogger?.warn?.("wallet.init.invalid_mnemonic");
               return Response.json({ error: "Invalid mnemonic" }, { status: 400 });
             }
             mnemonic = body.mnemonic;
           } else {
+            initLogger?.info?.("wallet.init.generating_mnemonic");
             mnemonic = generateMnemonic(wordlist, 256);
           }
 
           const mintUrl = body.mintUrl || "https://mint.minibits.cash/Bitcoin";
           const encrypted = !!body.passphrase;
 
+          initLogger?.info?.("wallet.init.resetting_config_file", { configFile: CONFIG_FILE });
           await Bun.write(CONFIG_FILE, "");
           await unlink(CONFIG_FILE);
 
           let config: WalletConfig;
 
           if (encrypted && body.passphrase) {
+            initLogger?.info?.("wallet.init.encrypting_mnemonic");
             const { ciphertext, salt } = await encryptMnemonic(mnemonic, body.passphrase);
 
+            initLogger?.info?.("wallet.init.writing_salt_file", { saltFile: SALT_FILE });
             await Bun.write(SALT_FILE, salt);
 
             config = {
@@ -75,6 +91,7 @@ export function createRouteHandlers(
             };
 
             stateManager.setLocked(ciphertext, mintUrl);
+            initLogger?.info?.("wallet.init.completed_locked", { mintUrl, state: "LOCKED" });
           } else {
             config = {
               version: 1,
@@ -84,19 +101,25 @@ export function createRouteHandlers(
               createdAt: new Date().toISOString(),
             };
 
-            const manager = await initializeWallet(config, undefined, logger);
+            initLogger?.info?.("wallet.init.initializing_wallet_manager", { mintUrl });
+            const manager = await initializeWallet(config, undefined, initLogger);
+            initLogger?.info?.("wallet.init.wallet_manager_ready", { mintUrl });
             const seed = mnemonicToSeedSync(mnemonic);
             stateManager.setUnlocked(manager, mintUrl, seed);
+            initLogger?.info?.("wallet.init.completed_unlocked", { mintUrl, state: "UNLOCKED" });
           }
 
+          initLogger?.info?.("wallet.init.writing_config_file", { configFile: CONFIG_FILE });
           await Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
 
           const output = encrypted
             ? `Initialized (locked). Mnemonic: ${mnemonic}\nIMPORTANT: Write down this mnemonic and keep it safe!`
             : `Initialized. Mnemonic: ${mnemonic}\nIMPORTANT: Write down this mnemonic and keep it safe!`;
 
+          initLogger?.info?.("wallet.init.response_ready", { encrypted, mintUrl });
           return Response.json({ output });
         } catch (error) {
+          initLogger?.error?.("wallet.init.failed", { error: serializeError(error) });
           const message = error instanceof Error ? error.message : String(error);
           return Response.json({ error: `Init failed: ${message}` }, { status: 500 });
         }
@@ -104,15 +127,21 @@ export function createRouteHandlers(
     },
     "/unlock": {
       POST: stateManager.requireLocked(async (req: Request, state: LockedState) => {
+        const unlockLogger = logger?.child?.({ route: "/unlock" }) ?? logger;
+
         try {
+          unlockLogger?.info?.("wallet.unlock.started", { mintUrl: state.mintUrl });
           const body = (await req.json()) as { passphrase: string };
 
           if (!body.passphrase) {
+            unlockLogger?.warn?.("wallet.unlock.missing_passphrase");
             return Response.json({ error: "Passphrase required" }, { status: 400 });
           }
 
+          unlockLogger?.info?.("wallet.unlock.reading_salt_file", { saltFile: SALT_FILE });
           const salt = await Bun.file(SALT_FILE).text();
           const { decryptMnemonic } = await import("./utils/crypto.js");
+          unlockLogger?.info?.("wallet.unlock.decrypting_mnemonic");
           const mnemonic = await decryptMnemonic(state.encryptedMnemonic, body.passphrase, salt);
 
           const config: WalletConfig = {
@@ -123,13 +152,22 @@ export function createRouteHandlers(
             createdAt: new Date().toISOString(),
           };
 
-          const manager = await initializeWallet(config, undefined, logger);
+          unlockLogger?.info?.("wallet.unlock.initializing_wallet_manager", {
+            mintUrl: state.mintUrl,
+          });
+          const manager = await initializeWallet(config, undefined, unlockLogger);
+          unlockLogger?.info?.("wallet.unlock.wallet_manager_ready", { mintUrl: state.mintUrl });
           const seed = mnemonicToSeedSync(mnemonic);
 
           stateManager.setUnlocked(manager, state.mintUrl, seed);
+          unlockLogger?.info?.("wallet.unlock.completed", {
+            mintUrl: state.mintUrl,
+            state: "UNLOCKED",
+          });
 
           return Response.json({ output: "Unlocked" });
         } catch (error) {
+          unlockLogger?.error?.("wallet.unlock.failed", { error: serializeError(error) });
           const message = error instanceof Error ? error.message : String(error);
           return Response.json({ error: `Unlock failed: ${message}` }, { status: 401 });
         }
@@ -504,11 +542,13 @@ async function runRoute(
     const durationMs = Math.round(performance.now() - startedAt);
     const level = response.status >= 500 ? "error" : response.status >= 400 ? "warn" : "info";
 
-    requestLogger?.log?.(level, "request.completed", {
-      durationMs,
-      state: getState().status,
-      status: response.status,
-    });
+    if (path !== "/status") {
+      requestLogger?.log?.(level, "request.completed", {
+        durationMs,
+        state: getState().status,
+        status: response.status,
+      });
+    }
 
     return response;
   } catch (error) {

package/src/utils/wallet.ts

@@ -14,38 +14,54 @@ export async function initializeWallet(
   passphrase?: string,
   logger?: Logger,
 ): Promise<Manager> {
+  const walletLogger = logger?.child?.({ component: "wallet-init" }) ?? logger;
+  walletLogger?.info?.("wallet.initialize.started", {
+    encrypted: config.encrypted,
+    mintUrl: config.mintUrl,
+    dbFile: DB_FILE,
+  });
+
   let mnemonic: string;
 
   if (config.encrypted) {
+    walletLogger?.info?.("wallet.initialize.decrypting_config_mnemonic", { saltFile: SALT_FILE });
     if (!passphrase) {
       throw new Error("Passphrase required for encrypted wallet");
     }
     const salt = await Bun.file(SALT_FILE).text();
     mnemonic = await decryptMnemonic(config.mnemonic, passphrase, salt);
   } else {
+    walletLogger?.info?.("wallet.initialize.using_plaintext_config_mnemonic");
     mnemonic = config.mnemonic;
   }
 
+  walletLogger?.info?.("wallet.initialize.derived_mnemonic");
   const seed = mnemonicToSeedSync(mnemonic);
 
+  walletLogger?.info?.("wallet.initialize.opening_database", { dbFile: DB_FILE });
   const repo = new SqliteRepositories({ database: new Database(DB_FILE) });
-  const walletLogger = logger?.child?.({ component: "coco" }) ?? logger;
-  const cocoLogger = walletLogger ?? new ConsoleLogger("Coco", { level: "info" });
+  const cocoLogger = walletLogger?.child?.({ component: "coco" }) ?? new ConsoleLogger("Coco", { level: "info" });
+  walletLogger?.info?.("wallet.initialize.preparing_signer");
   const sk = privateKeyFromSeedWords(mnemonic);
   const signer = async (t: EventTemplate) => finalizeEvent(t, sk);
+  walletLogger?.info?.("wallet.initialize.creating_npc_plugin", { npcUrl: "https://npubx.cash" });
   const npcPlugin = new NPCPlugin("https://npubx.cash", signer, {
     useWebsocket: true,
     logger: cocoLogger,
   });
+  walletLogger?.info?.("wallet.initialize.initializing_coco_core", { mintUrl: config.mintUrl });
   const coco = await initializeCoco({
     repo,
     seedGetter: async () => seed,
     logger: cocoLogger,
   });
 
+  walletLogger?.info?.("wallet.initialize.registering_npc_plugin");
   coco.use(npcPlugin);
 
+  walletLogger?.info?.("wallet.initialize.adding_trusted_mint", { mintUrl: config.mintUrl });
   await coco.mint.addMint(config.mintUrl, { trusted: true });
+  walletLogger?.info?.("wallet.initialize.completed", { mintUrl: config.mintUrl });
 
   return coco;
 }