@mauribadnights/clooks 0.4.1 → 0.5.0

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.0');
 // --- start ---
 program
     .command('start')
@@ -247,6 +248,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')

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/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.0",
   "description": "Persistent hook runtime for Claude Code — eliminates process spawning overhead and gives you observability",
   "bin": {
     "clooks": "./dist/cli.js"