@routstr/cocod 0.0.16 → 0.0.17

package/package.json

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

package/src/cli-shared.ts

@@ -42,6 +42,36 @@ export async function isDaemonRunning(): Promise<boolean> {
   }
 }
 
+const DAEMON_POLL_INTERVAL_MS = 100;
+const DAEMON_SLOW_START_WARNING_MS = 30_000;
+
+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") {
+        const status = result.output;
+        if (status === "LOCKED" || status === "UNLOCKED" || status === "ERROR") {
+          return;
+        }
+      }
+    } catch {
+      // Daemon may not be accepting requests yet
+    }
+
+    if (!warningShown.value && Date.now() - startedAt >= DAEMON_SLOW_START_WARNING_MS) {
+      warningShown.value = true;
+      console.log("Daemon is taking longer than expected, please wait...");
+    }
+
+    await sleep(DAEMON_POLL_INTERVAL_MS);
+  }
+}
+
 export async function startDaemonProcess(): Promise<void> {
   const proc = Bun.spawn({
     cmd: ["bun", "run", `${import.meta.dir}/index.ts`, "daemon"],
@@ -51,14 +81,21 @@ 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");
+    if (!warningShown.value && Date.now() - startedAt >= DAEMON_SLOW_START_WARNING_MS) {
+      warningShown.value = true;
+      console.log("Daemon is taking longer than expected, please wait...");
+    }
+  }
 }
 
 export async function ensureDaemonRunning(): Promise<void> {

package/src/daemon.ts

@@ -1,5 +1,7 @@
 import { mnemonicToSeedSync } from "@scure/bip39";
+import { closeSync, openSync, writeFileSync } from "node:fs";
 import { unlink } from "node:fs/promises";
+import process from "node:process";
 import { CONFIG_FILE, SOCKET_PATH, PID_FILE } from "./utils/config.js";
 import { createDaemonLogger, serializeError } from "./utils/logger.js";
 import { DaemonStateManager } from "./utils/state.js";
@@ -7,6 +9,69 @@ 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> {
+  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();
@@ -16,6 +81,8 @@ export async function startDaemon() {
     socketPath: SOCKET_PATH,
   });
 
+  await acquirePidLock(logger);
+
   try {
     const testConn = await Bun.connect({
       unix: SOCKET_PATH,
@@ -31,6 +98,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 +110,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 +145,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 +219,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) });