@mauribadnights/clooks 0.5.0 → 0.5.1

package/dist/cli.js

@@ -22,7 +22,7 @@ const program = new commander_1.Command();
 program
     .name('clooks')
     .description('Persistent hook runtime for Claude Code')
-    .version('0.5.0');
+    .version('0.5.1');
 // --- start ---
 program
     .command('start')
@@ -32,11 +32,13 @@ program
     .action(async (opts) => {
     const noWatch = opts.watch === false;
     if (!opts.foreground) {
-        // Background mode: check if already running and healthy
+        // Fix 6: Idempotent start — check if daemon is already healthy first
+        // This covers both normal PID file case AND orphaned daemon (no PID file)
         if ((0, server_js_1.isDaemonRunning)()) {
             const healthy = await (0, server_js_1.isDaemonHealthy)();
             if (healthy) {
-                console.log('Daemon is already running.');
+                const pid = (0, fs_1.existsSync)(constants_js_1.PID_FILE) ? (0, fs_1.readFileSync)(constants_js_1.PID_FILE, 'utf-8').trim() : '?';
+                console.log(`Daemon is already running (pid ${pid}).`);
                 process.exit(0);
             }
             // PID alive but daemon unhealthy — stale process after sleep/lid-close
@@ -45,6 +47,16 @@ program
                 console.log(`Cleaned up stale daemon (pid ${stalePid}), starting fresh`);
             }
         }
+        else {
+            // No PID file or dead PID — check if an orphaned daemon is on the port
+            const health = await (0, server_js_1.probeHealth)();
+            if (health && health.pid) {
+                // Orphaned daemon found — re-adopt it
+                (0, server_js_1.writePidFile)(health.pid);
+                console.log(`Adopted existing daemon (pid ${health.pid}).`);
+                process.exit(0);
+            }
+        }
         // Ensure config dir exists
         if (!(0, fs_1.existsSync)(constants_js_1.CONFIG_DIR)) {
             (0, fs_1.mkdirSync)(constants_js_1.CONFIG_DIR, { recursive: true });
@@ -63,7 +75,15 @@ program
             console.log(`Daemon started (pid ${pid}), listening on 127.0.0.1:${constants_js_1.DEFAULT_PORT}`);
         }
         else {
-            console.log('Daemon started. Check ~/.clooks/daemon.log if issues arise.');
+            // Fix 1: After spawn, if PID file missing, check if port responded (orphan recovery)
+            const health = await (0, server_js_1.probeHealth)();
+            if (health && health.pid) {
+                (0, server_js_1.writePidFile)(health.pid);
+                console.log(`Adopted existing daemon (pid ${health.pid}).`);
+            }
+            else {
+                console.log('Daemon started. Check ~/.clooks/daemon.log if issues arise.');
+            }
         }
         process.exit(0);
     }
@@ -86,12 +106,24 @@ program
 program
     .command('stop')
     .description('Stop the clooks daemon')
-    .action(() => {
+    .action(async () => {
+    // Try sync stop first (fast path with PID file)
     if ((0, server_js_1.stopDaemon)()) {
         console.log('Daemon stopped.');
+        return;
+    }
+    // Fix 4: No PID file — try async recovery via /health
+    const result = await (0, server_js_1.stopDaemonAsync)();
+    if (result.stopped) {
+        if (result.recovered) {
+            console.log(`Daemon stopped (recovered orphan, pid ${result.pid}).`);
+        }
+        else {
+            console.log('Daemon stopped.');
+        }
     }
     else {
-        console.log('Daemon is not running (no PID file or process not found).');
+        console.log('Daemon is not running.');
     }
 });
 // --- status ---
@@ -100,18 +132,28 @@ program
     .description('Show daemon status')
     .action(async () => {
     const running = (0, server_js_1.isDaemonRunning)();
+    const serviceStatus = (0, service_js_1.getServiceStatus)();
     if (!running) {
+        // Fix 2: No PID file or dead PID — check if orphaned daemon is on the port
+        const health = await (0, server_js_1.probeHealth)();
+        if (health && health.pid) {
+            // Orphaned daemon found — recover PID file
+            (0, server_js_1.writePidFile)(health.pid);
+            console.log(`Status: running (recovered, pid ${health.pid})`);
+            console.log(`Port: ${constants_js_1.DEFAULT_PORT}`);
+            console.log(`Service: ${serviceStatus}`);
+            console.log('Note: PID file was missing. Re-adopted orphaned daemon.');
+            return;
+        }
         console.log('Status: stopped');
         return;
     }
     const pid = (0, fs_1.existsSync)(constants_js_1.PID_FILE) ? (0, fs_1.readFileSync)(constants_js_1.PID_FILE, 'utf-8').trim() : '?';
-    // Try to hit health endpoint
-    // Service status
-    const serviceStatus = (0, service_js_1.getServiceStatus)();
+    // Try to hit health endpoint for detailed info
     try {
         const { get } = await import('http');
         const data = await new Promise((resolve, reject) => {
-            const req = get(`http://127.0.0.1:${constants_js_1.DEFAULT_PORT}/health`, (res) => {
+            const req = get(`http://127.0.0.1:${constants_js_1.DEFAULT_PORT}/health/detail`, (res) => {
                 let body = '';
                 res.on('data', (chunk) => { body += chunk.toString(); });
                 res.on('end', () => resolve(body));
@@ -333,6 +375,15 @@ program
             }
         }
     }
+    else {
+        // No PID file — check for orphaned daemon on the port
+        const health = await (0, server_js_1.probeHealth)();
+        if (health && health.pid) {
+            (0, server_js_1.writePidFile)(health.pid);
+            (0, sync_js_1.syncSettings)();
+            process.exit(0);
+        }
+    }
     // Ensure config dir exists
     if (!(0, fs_1.existsSync)(constants_js_1.CONFIG_DIR)) {
         (0, fs_1.mkdirSync)(constants_js_1.CONFIG_DIR, { recursive: true });

package/dist/server.d.ts

@@ -33,8 +33,18 @@ export declare function startDaemon(manifest: Manifest, metrics: MetricsCollecto
 }): Promise<ServerContext>;
 /**
  * Stop a running daemon by reading PID file and sending SIGTERM.
+ * If no PID file exists, tries to recover PID from the health endpoint.
  */
 export declare function stopDaemon(): boolean;
+/**
+ * Async version of stopDaemon that can recover orphaned daemons via /health.
+ * Returns { stopped: boolean, pid?: number, recovered?: boolean }.
+ */
+export declare function stopDaemonAsync(): Promise<{
+    stopped: boolean;
+    pid?: number;
+    recovered?: boolean;
+}>;
 /**
  * Check if daemon is currently running (PID check only).
  * Use for stop/status where a quick check is fine.
@@ -46,6 +56,18 @@ export declare function isDaemonRunning(): boolean;
  * Use for ensure-running and start where correctness matters.
  */
 export declare function isDaemonHealthy(): Promise<boolean>;
+/**
+ * Probe the health endpoint on the daemon port.
+ * Returns the parsed health response (including pid) or null if unreachable.
+ */
+export declare function probeHealth(port?: number): Promise<{
+    status: string;
+    pid: number;
+} | null>;
+/**
+ * Write a PID to the daemon PID file, creating the config dir if needed.
+ */
+export declare function writePidFile(pid: number): void;
 /**
  * Clean up a stale daemon: remove PID file and attempt to kill the process.
  * Returns the stale PID for logging purposes.

package/dist/server.js

@@ -5,8 +5,11 @@ exports.sessionAgents = void 0;
 exports.createServer = createServer;
 exports.startDaemon = startDaemon;
 exports.stopDaemon = stopDaemon;
+exports.stopDaemonAsync = stopDaemonAsync;
 exports.isDaemonRunning = isDaemonRunning;
 exports.isDaemonHealthy = isDaemonHealthy;
+exports.probeHealth = probeHealth;
+exports.writePidFile = writePidFile;
 exports.cleanupStaleDaemon = cleanupStaleDaemon;
 exports.startDaemonBackground = startDaemonBackground;
 const http_1 = require("http");
@@ -123,9 +126,9 @@ function createServer(manifest, metrics) {
     const server = (0, http_1.createServer)(async (req, res) => {
         const url = req.url ?? '/';
         const method = req.method ?? 'GET';
-        // Public health endpoint — minimal, no auth
+        // Public health endpoint — includes PID for orphan recovery
         if (method === 'GET' && url === '/health') {
-            sendJson(res, 200, { status: 'ok' });
+            sendJson(res, 200, { status: 'ok', pid: process.pid });
             return;
         }
         // Detailed health endpoint — authenticated if authToken configured
@@ -310,10 +313,23 @@ function startDaemon(manifest, metrics, options) {
     return new Promise((resolve, reject) => {
         const ctx = createServer(manifest, metrics);
         const port = manifest.settings?.port ?? constants_js_1.DEFAULT_PORT;
-        ctx.server.on('error', (err) => {
+        ctx.server.on('error', async (err) => {
             if (err.code === 'EADDRINUSE') {
-                log(`Port ${port} already in use`);
-                reject(new Error(`Port ${port} is already in use. Is another clooks instance running?`));
+                log(`Port ${port} already in use — attempting orphan recovery`);
+                // Try to recover: if a clooks daemon is already on this port, re-adopt it
+                try {
+                    const health = await probeHealth(port);
+                    if (health && health.pid) {
+                        writePidFile(health.pid);
+                        log(`Re-adopted orphaned daemon (pid ${health.pid})`);
+                        resolve(ctx);
+                        return;
+                    }
+                }
+                catch {
+                    // Probe failed — port is in use by something else
+                }
+                reject(new Error(`Port ${port} is already in use. Run 'clooks stop' to stop the existing daemon, or 'clooks status' to check.`));
             }
             else {
                 log(`Server error: ${err.message}`);
@@ -425,15 +441,21 @@ function startDaemon(manifest, metrics, options) {
 }
 /**
  * Stop a running daemon by reading PID file and sending SIGTERM.
+ * If no PID file exists, tries to recover PID from the health endpoint.
  */
 function stopDaemon() {
-    if (!(0, fs_1.existsSync)(constants_js_1.PID_FILE)) {
-        return false;
+    let pid = null;
+    if ((0, fs_1.existsSync)(constants_js_1.PID_FILE)) {
+        const pidStr = (0, fs_1.readFileSync)(constants_js_1.PID_FILE, 'utf-8').trim();
+        pid = parseInt(pidStr, 10);
+        if (isNaN(pid)) {
+            (0, fs_1.unlinkSync)(constants_js_1.PID_FILE);
+            pid = null;
+        }
     }
-    const pidStr = (0, fs_1.readFileSync)(constants_js_1.PID_FILE, 'utf-8').trim();
-    const pid = parseInt(pidStr, 10);
-    if (isNaN(pid)) {
-        (0, fs_1.unlinkSync)(constants_js_1.PID_FILE);
+    // If no PID from file, try synchronous recovery via health endpoint
+    // We can't await here (sync function), so use stopDaemonAsync for full recovery
+    if (pid === null) {
         return false;
     }
     try {
@@ -462,6 +484,57 @@ function stopDaemon() {
     }, 2000);
     return true;
 }
+/**
+ * Async version of stopDaemon that can recover orphaned daemons via /health.
+ * Returns { stopped: boolean, pid?: number, recovered?: boolean }.
+ */
+async function stopDaemonAsync() {
+    let pid = null;
+    if ((0, fs_1.existsSync)(constants_js_1.PID_FILE)) {
+        const pidStr = (0, fs_1.readFileSync)(constants_js_1.PID_FILE, 'utf-8').trim();
+        pid = parseInt(pidStr, 10);
+        if (isNaN(pid)) {
+            (0, fs_1.unlinkSync)(constants_js_1.PID_FILE);
+            pid = null;
+        }
+    }
+    // No PID file — try health endpoint recovery
+    if (pid === null) {
+        const health = await probeHealth();
+        if (health && health.pid) {
+            pid = health.pid;
+            log(`Recovered orphaned daemon PID ${pid} from /health for stop`);
+        }
+    }
+    if (pid === null) {
+        return { stopped: false };
+    }
+    const recovered = !(0, fs_1.existsSync)(constants_js_1.PID_FILE);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            if ((0, fs_1.existsSync)(constants_js_1.PID_FILE))
+                (0, fs_1.unlinkSync)(constants_js_1.PID_FILE);
+        }
+        catch {
+            // ignore
+        }
+        return { stopped: false };
+    }
+    // Clean up PID file after a moment
+    setTimeout(() => {
+        try {
+            if ((0, fs_1.existsSync)(constants_js_1.PID_FILE))
+                (0, fs_1.unlinkSync)(constants_js_1.PID_FILE);
+        }
+        catch {
+            // ignore
+        }
+    }, 2000);
+    return { stopped: true, pid, recovered };
+}
 /**
  * Check if daemon is currently running (PID check only).
  * Use for stop/status where a quick check is fine.
@@ -521,6 +594,42 @@ async function isDaemonHealthy() {
         return false;
     }
 }
+/**
+ * Probe the health endpoint on the daemon port.
+ * Returns the parsed health response (including pid) or null if unreachable.
+ */
+async function probeHealth(port) {
+    const p = port ?? constants_js_1.DEFAULT_PORT;
+    try {
+        const { get } = await import('http');
+        const data = await new Promise((resolve, reject) => {
+            const req = get(`http://127.0.0.1:${p}/health`, (res) => {
+                let body = '';
+                res.on('data', (chunk) => { body += chunk.toString(); });
+                res.on('end', () => resolve(body));
+            });
+            req.on('error', reject);
+            req.setTimeout(2000, () => { req.destroy(); reject(new Error('timeout')); });
+        });
+        const health = JSON.parse(data);
+        if (health.status === 'ok' && typeof health.pid === 'number') {
+            return health;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write a PID to the daemon PID file, creating the config dir if needed.
+ */
+function writePidFile(pid) {
+    if (!(0, fs_1.existsSync)(constants_js_1.CONFIG_DIR)) {
+        (0, fs_1.mkdirSync)(constants_js_1.CONFIG_DIR, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(constants_js_1.PID_FILE, String(pid), 'utf-8');
+}
 /**
  * Clean up a stale daemon: remove PID file and attempt to kill the process.
  * Returns the stale PID for logging purposes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mauribadnights/clooks",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Persistent hook runtime for Claude Code — eliminates process spawning overhead and gives you observability",
   "bin": {
     "clooks": "./dist/cli.js"