@shetty4l/core 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shetty4l/core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Shared infrastructure primitives for Bun/TypeScript services",
   "repository": {
     "type": "git",

package/src/cli.ts

@@ -40,6 +40,74 @@ export function formatUptime(seconds: number): string {
   return `${hours}h ${mins}m`;
 }
 
+// --- Log file tail ---
+
+export interface LogsCommandOpts {
+  /** Absolute path to the log file. */
+  logFile: string;
+  /** Default number of lines when no count is specified. */
+  defaultCount?: number;
+  /** Message to display when the log file does not exist or is empty. */
+  emptyMessage?: string;
+}
+
+/**
+ * Create a `logs` command handler that tails a log file.
+ *
+ * Supports a positional count argument (`logs 50`) and the standard `--json` flag.
+ * Returns exit code 0 on success, 1 on error.
+ */
+export function createLogsCommand(opts: LogsCommandOpts): CommandHandler {
+  const {
+    logFile,
+    defaultCount = 20,
+    emptyMessage = "No log entries yet.",
+  } = opts;
+
+  return async (args: string[], json: boolean): Promise<number> => {
+    const count = args.length > 0 ? Number.parseInt(args[0], 10) : defaultCount;
+    if (Number.isNaN(count) || count <= 0) {
+      console.error(`Invalid count: ${args[0]}`);
+      return 1;
+    }
+
+    const file = Bun.file(logFile);
+    if (!(await file.exists())) {
+      if (json) {
+        console.log(JSON.stringify({ lines: [], file: logFile }));
+      } else {
+        console.log(emptyMessage);
+      }
+      return 0;
+    }
+
+    const text = await file.text();
+    const allLines = text.split("\n").filter((l) => l.length > 0);
+
+    if (allLines.length === 0) {
+      if (json) {
+        console.log(JSON.stringify({ lines: [], file: logFile }));
+      } else {
+        console.log(emptyMessage);
+      }
+      return 0;
+    }
+
+    const lines = allLines.slice(-count);
+
+    if (json) {
+      console.log(
+        JSON.stringify({ lines, file: logFile, total: allLines.length }),
+      );
+    } else {
+      for (const line of lines) {
+        console.log(line);
+      }
+    }
+    return 0;
+  };
+}
+
 // --- Command dispatch ---
 
 export type CommandHandler = (

package/src/daemon.ts

@@ -25,8 +25,10 @@ export interface DaemonManagerOpts {
   serveCommand?: string;
   /** Health endpoint URL for verifying the daemon is responsive. */
   healthUrl?: string;
-  /** Milliseconds to wait after spawn before health-checking. Defaults to 500. */
-  startupWaitMs?: number;
+  /** Milliseconds between health poll attempts during startup. Defaults to 500. */
+  startupPollMs?: number;
+  /** Total milliseconds to wait for health endpoint after spawn. Defaults to 10000. */
+  healthTimeoutMs?: number;
   /** Milliseconds to wait for graceful stop before SIGKILL. Defaults to 5000. */
   stopTimeoutMs?: number;
 }
@@ -94,7 +96,8 @@ export function createDaemonManager(opts: DaemonManagerOpts): DaemonManager {
     cliPath,
     serveCommand = "serve",
     healthUrl,
-    startupWaitMs = 500,
+    startupPollMs = 500,
+    healthTimeoutMs = 10_000,
     stopTimeoutMs = 5000,
   } = opts;
 
@@ -157,8 +160,43 @@ export function createDaemonManager(opts: DaemonManagerOpts): DaemonManager {
       });
 
       writePid(pidFile, proc.pid);
-      await new Promise((resolve) => setTimeout(resolve, startupWaitMs));
 
+      if (healthUrl) {
+        // Poll health endpoint until responsive or timeout
+        let waited = 0;
+        while (waited < healthTimeoutMs) {
+          await new Promise((resolve) => setTimeout(resolve, startupPollMs));
+          waited += startupPollMs;
+
+          if (!isProcessRunning(proc.pid)) {
+            removePidFile(pidFile);
+            return err(
+              `${name}: process exited during startup (check ${logFile})`,
+            );
+          }
+
+          const health = await checkHealth();
+          if (health.healthy) {
+            return ok({
+              running: true,
+              pid: proc.pid,
+              uptime: health.uptime,
+              port: health.port,
+            });
+          }
+        }
+
+        // Timed out — kill the unresponsive process
+        process.kill(proc.pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        removePidFile(pidFile);
+        return err(
+          `${name}: health check timed out after ${healthTimeoutMs}ms (check ${logFile})`,
+        );
+      }
+
+      // No health URL — fall back to PID check after one poll interval
+      await new Promise((resolve) => setTimeout(resolve, startupPollMs));
       const status = await manager.status();
       if (status.running) {
         return ok(status);
@@ -195,7 +233,13 @@ export function createDaemonManager(opts: DaemonManagerOpts): DaemonManager {
     },
 
     async restart(): Promise<Result<DaemonStatus>> {
-      await manager.stop();
+      const stopResult = await manager.stop();
+      // Propagate stop errors unless the service simply wasn't running
+      if (!stopResult.ok && !stopResult.error.includes("not running")) {
+        return stopResult;
+      }
+      // Brief delay to let the OS release the port
+      await new Promise((resolve) => setTimeout(resolve, startupPollMs));
       return manager.start();
     },
   };