@routstr/cocod 0.0.16 → 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.16",
+  "version": "0.0.18",
   "module": "src/index.ts",
   "type": "module",
   "private": false,

package/src/cli-shared.ts

@@ -42,6 +42,64 @@ export async function isDaemonRunning(): Promise<boolean> {
   }
 }
 
+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));
+}
+
+async function waitForDaemonReady(startedAt: number, warningShown: { value: boolean }): Promise<void> {
+  for (;;) {
+    try {
+      const result = await callDaemon("/status");
+      if (typeof result.output === "string") {
+        return;
+      }
+    } catch {
+      // Daemon may not be accepting requests yet
+    }
+
+    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"],
@@ -51,14 +109,28 @@ export async function startDaemonProcess(): Promise<void> {
   });
   proc.unref();
 
-  for (let i = 0; i < 50; i++) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
+  const startedAt = Date.now();
+  const warningShown = { value: false };
+
+  for (;;) {
+    await sleep(DAEMON_POLL_INTERVAL_MS);
     if (await isDaemonRunning()) {
+      await waitForDaemonReady(startedAt, warningShown);
       return;
     }
-  }
 
-  throw new Error("Daemon failed to start within 5 seconds");
+    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");
+    }
+  }
 }
 
 export async function ensureDaemonRunning(): Promise<void> {
@@ -76,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,21 +1,90 @@
 import { mnemonicToSeedSync } from "@scure/bip39";
-import { unlink } from "node:fs/promises";
-import { CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.js";
+import { closeSync, openSync, writeFileSync } from "node:fs";
+import { mkdir, unlink } from "node:fs/promises";
+import process from "node:process";
+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";
 import { createRouteHandlers, buildRoutes } from "./routes.js";
 import type { WalletConfig } from "./utils/config.js";
 
+async function isProcessAlive(pid: number): Promise<boolean> {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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();
+    const existingPid = Number.parseInt(existingPidText, 10);
+
+    if (await isProcessAlive(existingPid)) {
+      logger.warn("daemon.start.skipped", {
+        reason: "already_running",
+        pid: existingPid,
+        pidFile: PID_FILE,
+      });
+      await logger.flush();
+      console.error(`Error: Daemon is already running with PID ${existingPid}`);
+      process.exit(1);
+    }
+
+    logger.warn("daemon.pid.stale", {
+      pid: existingPidText || null,
+      pidFile: PID_FILE,
+    });
+    try {
+      await unlink(PID_FILE);
+    } catch {
+      // File may already be gone
+    }
+  }
+
+  try {
+    const fd = openSync(PID_FILE, "wx");
+    try {
+      writeFileSync(fd, `${process.pid}`);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    const currentPidText = (await Bun.file(PID_FILE).text()).trim();
+    const currentPid = Number.parseInt(currentPidText, 10);
+
+    logger.warn("daemon.start.skipped", {
+      reason: "pid_lock_exists",
+      pid: Number.isNaN(currentPid) ? currentPidText : currentPid,
+      pidFile: PID_FILE,
+    });
+    await logger.flush();
+    console.error("Error: Daemon is already starting or running");
+    process.exit(1);
+  }
+}
+
 export async function startDaemon() {
   const stateManager = new DaemonStateManager();
-  const logger = createDaemonLogger();
+  const logger = createDaemonLogger({ mirrorToConsole: false });
 
   logger.info("daemon.start.requested", {
     pidFile: PID_FILE,
     socketPath: SOCKET_PATH,
   });
 
+  await acquirePidLock(logger);
+
   try {
     const testConn = await Bun.connect({
       unix: SOCKET_PATH,
@@ -31,6 +100,11 @@ export async function startDaemon() {
       reason: "already_running",
       socketPath: SOCKET_PATH,
     });
+    try {
+      await unlink(PID_FILE);
+    } catch {
+      // File might not exist
+    }
     await logger.flush();
     console.error(`Error: Daemon is already running on ${SOCKET_PATH}`);
     process.exit(1);
@@ -38,25 +112,11 @@ export async function startDaemon() {
     // Not running, safe to proceed
   }
 
-  try {
-    await Bun.write(PID_FILE, "");
-    await unlink(PID_FILE);
-  } catch {
-    // Directory creation failed or file didn't exist
-  }
-
   try {
     await unlink(SOCKET_PATH);
   } catch {
     // File might not exist
   }
-  try {
-    await unlink(PID_FILE);
-  } catch {
-    // File might not exist
-  }
-
-  await Bun.write(PID_FILE, process.pid.toString());
 
   try {
     const configExists = await Bun.file(CONFIG_FILE).exists();
@@ -87,6 +147,7 @@ export async function startDaemon() {
       }
     } else {
       logger.info("wallet.config_missing");
+      logger.info("wallet.uninitialized");
     }
   } catch (error) {
     logger.warn("wallet.config_load_failed", { error: serializeError(error) });
@@ -160,9 +221,6 @@ export async function startDaemon() {
   });
 
   logger.info("daemon.started", { socketPath: SOCKET_PATH });
-  if (stateManager.isUninitialized()) {
-    logger.info("wallet.uninitialized");
-  }
 
   process.on("unhandledRejection", (error) => {
     logger.error("daemon.unhandled_rejection", { error: serializeError(error) });

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;
 }