@mauribadnights/clooks 0.4.1 → 0.5.1

package/dist/cli.js

@@ -15,13 +15,14 @@ const service_js_1 = require("./service.js");
 const constants_js_1 = require("./constants.js");
 const tui_js_1 = require("./tui.js");
 const agent_js_1 = require("./agent.js");
+const import_plugins_js_1 = require("./import-plugins.js");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const program = new commander_1.Command();
 program
     .name('clooks')
     .description('Persistent hook runtime for Claude Code')
-    .version('0.4.1');
+    .version('0.5.1');
 // --- start ---
 program
     .command('start')
@@ -31,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
@@ -44,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 });
@@ -62,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);
     }
@@ -85,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 ---
@@ -99,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));
@@ -247,6 +290,65 @@ program
         }
     }
 });
+// --- import-plugins ---
+program
+    .command('import-plugins')
+    .description('Import hooks from installed Claude Code plugins')
+    .action(async () => {
+    try {
+        const { plugins, handlers } = (0, import_plugins_js_1.importPlugins)();
+        if (plugins.length === 0) {
+            console.log('No Claude Code plugins with hooks found.');
+            return;
+        }
+        // Load current manifest
+        const manifest = (0, manifest_js_1.loadCompositeManifest)();
+        // Remove previously imported plugin handlers (those with "/" matching discovered plugin names)
+        const pluginNames = new Set(plugins.map(p => p.name));
+        for (const [event, eventHandlers] of Object.entries(manifest.handlers)) {
+            if (!eventHandlers)
+                continue;
+            manifest.handlers[event] = eventHandlers.filter(h => {
+                const slashIdx = h.id.indexOf('/');
+                if (slashIdx === -1)
+                    return true; // user handler, keep
+                const prefix = h.id.substring(0, slashIdx);
+                return !pluginNames.has(prefix); // remove if prefix matches a discovered plugin
+            });
+        }
+        // Add new imported handlers
+        for (const [event, eventHandlers] of Object.entries(handlers)) {
+            const hookEvent = event;
+            if (!manifest.handlers[hookEvent])
+                manifest.handlers[hookEvent] = [];
+            manifest.handlers[hookEvent].push(...eventHandlers);
+        }
+        // Write updated manifest
+        const { stringify: stringifyYaml } = await import('yaml');
+        const { writeFileSync } = await import('fs');
+        const yamlStr = '# clooks manifest — updated by import-plugins\n' +
+            `# Date: ${new Date().toISOString()}\n\n` +
+            stringifyYaml(manifest);
+        writeFileSync(constants_js_1.MANIFEST_PATH, yamlStr, 'utf-8');
+        // Sync settings.json
+        const syncAdded = (0, sync_js_1.syncSettings)();
+        // Report
+        const totalHandlers = Object.values(handlers).reduce((sum, arr) => sum + arr.length, 0);
+        console.log(`Imported ${totalHandlers} handler(s) from ${plugins.length} CC plugin(s):`);
+        for (const p of plugins) {
+            const count = Object.values(p.hooks).reduce((sum, arr) => sum + arr.filter(h => h.type === 'command').length, 0);
+            const enhanced = p.clooksEnhancements ? ' (with clooks.yaml)' : '';
+            console.log(`  ${p.name} v${p.version}: ${count} handler(s)${enhanced}`);
+        }
+        if (syncAdded.length > 0) {
+            console.log(`Synced HTTP hooks for: ${syncAdded.join(', ')}`);
+        }
+    }
+    catch (err) {
+        console.error('Import failed:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
 // --- ensure-running ---
 program
     .command('ensure-running')
@@ -273,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/import-plugins.d.ts

@@ -0,0 +1,50 @@
+import type { HandlerConfig, HookEvent } from './types.js';
+/** A discovered Claude Code plugin */
+export interface CCPlugin {
+    name: string;
+    version: string;
+    path: string;
+    hooks: Partial<Record<HookEvent, CCHookEntry[]>>;
+    clooksEnhancements?: Partial<Record<string, ClooksEnhancement>>;
+}
+interface CCHookEntry {
+    type: 'command' | 'http' | 'prompt' | 'agent';
+    command?: string;
+    url?: string;
+    matcher?: string;
+    timeout?: number;
+}
+/** clooks.yaml enhancement overlay per handler */
+interface ClooksEnhancement {
+    filter?: string;
+    project?: string;
+    agent?: string;
+    async?: boolean;
+    depends?: string[];
+    sessionIsolation?: boolean;
+    batchGroup?: string;
+    type?: 'llm';
+    model?: string;
+    prompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Discover all installed Claude Code plugins that have hooks.
+ */
+export declare function discoverCCPlugins(ccPluginsDir?: string): CCPlugin[];
+/**
+ * Convert discovered CC plugins into clooks manifest handler entries.
+ * Applies clooks.yaml enhancements if present.
+ * Handler IDs namespaced as "pluginName/derivedId".
+ */
+export declare function convertPluginsToHandlers(plugins: CCPlugin[]): Partial<Record<HookEvent, HandlerConfig[]>>;
+/**
+ * Import all Claude Code plugins into clooks.
+ * Returns the discovered plugins and generated handlers.
+ */
+export declare function importPlugins(ccPluginsDir?: string): {
+    plugins: CCPlugin[];
+    handlers: Partial<Record<HookEvent, HandlerConfig[]>>;
+};
+export {};

package/dist/import-plugins.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverCCPlugins = discoverCCPlugins;
+exports.convertPluginsToHandlers = convertPluginsToHandlers;
+exports.importPlugins = importPlugins;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const yaml_1 = require("yaml");
+const constants_js_1 = require("./constants.js");
+/** Path to Claude Code's plugin cache */
+const CC_PLUGINS_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'plugins', 'cache');
+/**
+ * Discover all installed Claude Code plugins that have hooks.
+ */
+function discoverCCPlugins(ccPluginsDir) {
+    const dir = ccPluginsDir ?? CC_PLUGINS_DIR;
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const results = [];
+    for (const entry of (0, fs_1.readdirSync)(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const pluginDir = (0, path_1.join)(dir, entry.name);
+        // Read plugin.json
+        const pluginJsonPath = (0, path_1.join)(pluginDir, '.claude-plugin', 'plugin.json');
+        if (!(0, fs_1.existsSync)(pluginJsonPath))
+            continue;
+        let pluginJson;
+        try {
+            pluginJson = JSON.parse((0, fs_1.readFileSync)(pluginJsonPath, 'utf-8'));
+        }
+        catch {
+            continue;
+        }
+        // Read hooks
+        const hooksJsonPath = (0, path_1.join)(pluginDir, 'hooks', 'hooks.json');
+        let hooks = {};
+        if ((0, fs_1.existsSync)(hooksJsonPath)) {
+            try {
+                hooks = JSON.parse((0, fs_1.readFileSync)(hooksJsonPath, 'utf-8'));
+            }
+            catch { /* skip */ }
+        }
+        // Also check if hooks are inline in plugin.json
+        if (pluginJson.hooks && typeof pluginJson.hooks === 'string') {
+            const inlineHooksPath = (0, path_1.join)(pluginDir, pluginJson.hooks);
+            if ((0, fs_1.existsSync)(inlineHooksPath)) {
+                try {
+                    hooks = JSON.parse((0, fs_1.readFileSync)(inlineHooksPath, 'utf-8'));
+                }
+                catch { /* skip */ }
+            }
+        }
+        if (!hooks || Object.keys(hooks).length === 0)
+            continue;
+        // Read optional clooks.yaml enhancement
+        let enhancements = undefined;
+        const clooksYamlPath = (0, path_1.join)(pluginDir, 'clooks.yaml');
+        if ((0, fs_1.existsSync)(clooksYamlPath)) {
+            try {
+                enhancements = (0, yaml_1.parse)((0, fs_1.readFileSync)(clooksYamlPath, 'utf-8'));
+            }
+            catch { /* skip */ }
+        }
+        results.push({
+            name: pluginJson.name || entry.name,
+            version: pluginJson.version || '0.0.0',
+            path: pluginDir,
+            hooks: parseHooks(hooks),
+            clooksEnhancements: enhancements?.handlers,
+        });
+    }
+    return results;
+}
+/**
+ * Parse Claude Code hooks.json format into flat event->hooks map.
+ * CC format: { "PostToolUse": [{ "matcher": "...", "hooks": [{ "type": "command", ... }] }] }
+ */
+function parseHooks(hooks) {
+    const result = {};
+    for (const [event, ruleGroups] of Object.entries(hooks)) {
+        if (!constants_js_1.HOOK_EVENTS.includes(event) || !Array.isArray(ruleGroups))
+            continue;
+        const entries = [];
+        for (const rule of ruleGroups) {
+            if (Array.isArray(rule.hooks)) {
+                for (const hook of rule.hooks) {
+                    entries.push({ ...hook, matcher: rule.matcher });
+                }
+            }
+        }
+        if (entries.length > 0) {
+            result[event] = entries;
+        }
+    }
+    return result;
+}
+/**
+ * Convert discovered CC plugins into clooks manifest handler entries.
+ * Applies clooks.yaml enhancements if present.
+ * Handler IDs namespaced as "pluginName/derivedId".
+ */
+function convertPluginsToHandlers(plugins) {
+    const handlers = {};
+    for (const plugin of plugins) {
+        for (const [event, hookEntries] of Object.entries(plugin.hooks)) {
+            const hookEvent = event;
+            if (!handlers[hookEvent])
+                handlers[hookEvent] = [];
+            for (let i = 0; i < hookEntries.length; i++) {
+                const hook = hookEntries[i];
+                if (hook.type !== 'command' || !hook.command)
+                    continue; // Only import command hooks
+                // Derive handler ID from command
+                const baseId = deriveId(hook.command, hookEvent, i);
+                const id = `${plugin.name}/${baseId}`;
+                // Build base handler config
+                const handler = {
+                    id,
+                    type: 'script',
+                    command: resolvePluginVars(hook.command, plugin.path),
+                    timeout: hook.timeout ? hook.timeout * 1000 : 5000,
+                    enabled: true,
+                };
+                // Apply clooks.yaml enhancements if present
+                const enhancement = plugin.clooksEnhancements?.[baseId];
+                if (enhancement) {
+                    applyEnhancement(handler, enhancement, plugin.name);
+                }
+                handlers[hookEvent].push(handler);
+            }
+        }
+    }
+    return handlers;
+}
+/** Apply clooks.yaml enhancement to a handler */
+function applyEnhancement(handler, enhancement, pluginName) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic property assignment from enhancement overlay
+    const h = handler;
+    if (enhancement.filter)
+        h.filter = enhancement.filter;
+    if (enhancement.project)
+        h.project = enhancement.project;
+    if (enhancement.agent)
+        h.agent = enhancement.agent;
+    if (enhancement.async !== undefined)
+        h.async = enhancement.async;
+    if (enhancement.depends) {
+        h.depends = enhancement.depends.map(d => d.includes('/') ? d : `${pluginName}/${d}`);
+    }
+    if (enhancement.sessionIsolation)
+        h.sessionIsolation = enhancement.sessionIsolation;
+    // Allow converting to LLM handler
+    if (enhancement.type === 'llm' && enhancement.model && enhancement.prompt) {
+        h.type = 'llm';
+        h.model = enhancement.model;
+        h.prompt = enhancement.prompt;
+        delete h.command;
+        if (enhancement.batchGroup)
+            h.batchGroup = enhancement.batchGroup;
+        if (enhancement.maxTokens)
+            h.maxTokens = enhancement.maxTokens;
+        if (enhancement.temperature)
+            h.temperature = enhancement.temperature;
+    }
+}
+/** Resolve ${CLAUDE_PLUGIN_ROOT} and similar vars in commands */
+function resolvePluginVars(command, pluginPath) {
+    return command
+        .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginPath)
+        .replace(/\$CLAUDE_PLUGIN_ROOT/g, pluginPath);
+}
+/** Derive a handler ID from command */
+function deriveId(command, event, index) {
+    // Extract script filename
+    const jsMatch = command.match(/[\\/]([^\\/]+)\.(?:js|ts|py|sh)(?:\s|"|'|$)/);
+    if (jsMatch) {
+        return jsMatch[1].toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    }
+    const moduleMatch = command.match(/python3?\s+-m\s+([\w.]+)/);
+    if (moduleMatch) {
+        const parts = moduleMatch[1].split('.');
+        return parts.slice(-2).join('-').toLowerCase();
+    }
+    return `${event.toLowerCase()}-${index}`;
+}
+/**
+ * Import all Claude Code plugins into clooks.
+ * Returns the discovered plugins and generated handlers.
+ */
+function importPlugins(ccPluginsDir) {
+    const plugins = discoverCCPlugins(ccPluginsDir);
+    const handlers = convertPluginsToHandlers(plugins);
+    return { plugins, handlers };
+}

package/dist/migrate.js

@@ -10,6 +10,7 @@ const path_1 = require("path");
 const os_1 = require("os");
 const constants_js_1 = require("./constants.js");
 const builtin_hooks_js_1 = require("./builtin-hooks.js");
+const import_plugins_js_1 = require("./import-plugins.js");
 const yaml_1 = require("yaml");
 /**
  * Find the Claude Code settings.json path.
@@ -154,6 +155,14 @@ function migrate(options) {
         timeout: 6000,
         enabled: true,
     });
+    // Import Claude Code plugin hooks
+    const { handlers: ccHandlers } = (0, import_plugins_js_1.importPlugins)();
+    for (const [event, eventHandlers] of Object.entries(ccHandlers)) {
+        const hookEvent = event;
+        if (!manifestHandlers[hookEvent])
+            manifestHandlers[hookEvent] = [];
+        manifestHandlers[hookEvent].push(...eventHandlers);
+    }
     // Write manifest.yaml
     const manifest = {
         handlers: manifestHandlers,

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/dist/sync.js

@@ -6,6 +6,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const manifest_js_1 = require("./manifest.js");
+const import_plugins_js_1 = require("./import-plugins.js");
 const constants_js_1 = require("./constants.js");
 /**
  * Find the Claude Code settings.json path.
@@ -42,6 +43,20 @@ function syncSettings(options) {
     }
     else {
         manifest = (0, manifest_js_1.loadCompositeManifest)();
+        // Also merge in Claude Code plugin hooks
+        const { handlers: ccHandlers } = (0, import_plugins_js_1.importPlugins)();
+        for (const [event, eventHandlers] of Object.entries(ccHandlers)) {
+            const hookEvent = event;
+            if (!manifest.handlers[hookEvent])
+                manifest.handlers[hookEvent] = [];
+            // Avoid duplicates: only add handlers whose IDs are not already present
+            const existingIds = new Set(manifest.handlers[hookEvent].map(h => h.id));
+            for (const handler of eventHandlers) {
+                if (!existingIds.has(handler.id)) {
+                    manifest.handlers[hookEvent].push(handler);
+                }
+            }
+        }
     }
     const port = manifest.settings?.port ?? constants_js_1.DEFAULT_PORT;
     const authToken = manifest.settings?.authToken;

package/package.json

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