@swarmify/agents-cli 1.13.3 → 1.14.0

package/dist/lib/hooks.js

@@ -1,846 +0,0 @@
-/**
- * Hook management -- discovery, registration, and syncing of event hooks.
- *
- * Hooks are shell scripts in ~/.agents/hooks/ that fire on agent events
- * (tool calls, session start, etc.). Each hook directory contains a manifest
- * (agents.yaml) declaring events, matchers, and timeout. This module handles
- * parsing those manifests, registering hooks into agent-native settings files,
- * and syncing them across version switches.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import * as TOML from 'smol-toml';
-import { AGENTS, HOOKS_CAPABLE_AGENTS } from './agents.js';
-import { getAgentsDir, getHooksDir as getCentralHooksDir, getProjectAgentsDir } from './state.js';
-import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
-const SCRIPT_EXTENSIONS = new Set([
-    '.sh',
-    '.bash',
-    '.zsh',
-    '.py',
-    '.js',
-    '.ts',
-    '.mjs',
-    '.cjs',
-    '.rb',
-    '.pl',
-    '.ps1',
-    '.cmd',
-    '.bat',
-]);
-function isExecutable(mode) {
-    return (mode & 0o111) !== 0;
-}
-function getHooksDir(agentId) {
-    const agent = AGENTS[agentId];
-    const home = getEffectiveHome(agentId);
-    return path.join(home, `.${agentId}`, agent.hooksDir);
-}
-function getProjectHooksDirs(agentId, cwd) {
-    const agent = AGENTS[agentId];
-    const dirs = [];
-    const projectAgentsDir = getProjectAgentsDir(cwd);
-    if (projectAgentsDir) {
-        dirs.push(path.join(projectAgentsDir, 'hooks'));
-    }
-    dirs.push(path.join(cwd, `.${agentId}`, agent.hooksDir));
-    return dirs;
-}
-function ensureDir(dir) {
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-}
-function removeHookFiles(dir, name) {
-    if (!fs.existsSync(dir)) {
-        return;
-    }
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const ext = path.extname(file);
-        const base = path.basename(file, ext);
-        if (base === name) {
-            const fullPath = path.join(dir, file);
-            const stat = fs.statSync(fullPath);
-            if (stat.isFile()) {
-                fs.unlinkSync(fullPath);
-            }
-        }
-    }
-}
-function listHookEntriesFromDir(dir) {
-    if (!fs.existsSync(dir)) {
-        return [];
-    }
-    const files = [];
-    for (const file of fs.readdirSync(dir)) {
-        const fullPath = path.join(dir, file);
-        const stat = fs.statSync(fullPath);
-        if (!stat.isFile())
-            continue;
-        const ext = path.extname(file);
-        const base = path.basename(file, ext);
-        files.push({
-            name: file,
-            base,
-            ext,
-            fullPath,
-            isExec: isExecutable(stat.mode),
-        });
-    }
-    const grouped = new Map();
-    for (const file of files) {
-        const list = grouped.get(file.base) || [];
-        list.push(file);
-        grouped.set(file.base, list);
-    }
-    const entries = [];
-    for (const [base, group] of grouped) {
-        group.sort((a, b) => a.name.localeCompare(b.name));
-        const script = group.find((f) => f.isExec) ||
-            group.find((f) => SCRIPT_EXTENSIONS.has(f.ext.toLowerCase())) ||
-            group[0];
-        if (!script)
-            continue;
-        const data = group.find((f) => f !== script);
-        entries.push({
-            name: base,
-            scriptPath: script.fullPath,
-            dataFile: data ? data.fullPath : undefined,
-        });
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    return entries;
-}
-function buildHookMap(entries) {
-    const map = new Map();
-    for (const entry of entries) {
-        map.set(entry.name, entry);
-    }
-    return map;
-}
-function copyHook(entry, targetDir) {
-    ensureDir(targetDir);
-    removeHookFiles(targetDir, entry.name);
-    const scriptTarget = path.join(targetDir, path.basename(entry.scriptPath));
-    fs.copyFileSync(entry.scriptPath, scriptTarget);
-    const scriptStat = fs.statSync(entry.scriptPath);
-    fs.chmodSync(scriptTarget, scriptStat.mode);
-    if (entry.dataFile) {
-        const dataTarget = path.join(targetDir, path.basename(entry.dataFile));
-        fs.copyFileSync(entry.dataFile, dataTarget);
-    }
-}
-/**
- * Check if a hook exists for an agent.
- */
-export function hookExists(agentId, hookName) {
-    const agent = AGENTS[agentId];
-    if (!agent.supportsHooks) {
-        return false;
-    }
-    const hooksDir = getHooksDir(agentId);
-    if (!fs.existsSync(hooksDir)) {
-        return false;
-    }
-    const files = fs.readdirSync(hooksDir);
-    return files.some((file) => {
-        const ext = path.extname(file);
-        const baseName = path.basename(file, ext);
-        return baseName === hookName && SCRIPT_EXTENSIONS.has(ext);
-    });
-}
-/**
- * Normalize content for comparison (trim, normalize line endings).
- */
-function normalizeContent(content) {
-    return content.replace(/\r\n/g, '\n').trim();
-}
-/**
- * Get the installed hook entry for an agent.
- */
-function getInstalledHookEntry(agentId, hookName) {
-    const hooksDir = getHooksDir(agentId);
-    const entries = listHookEntriesFromDir(hooksDir);
-    return entries.find((e) => e.name === hookName) || null;
-}
-/**
- * Check if installed hook content matches source hook content.
- * Compares both script file and data file (if present).
- */
-export function hookContentMatches(agentId, hookName, sourceEntry) {
-    const agent = AGENTS[agentId];
-    if (!agent.supportsHooks) {
-        return false;
-    }
-    const installedEntry = getInstalledHookEntry(agentId, hookName);
-    if (!installedEntry) {
-        return false;
-    }
-    try {
-        const installedScript = fs.readFileSync(installedEntry.scriptPath, 'utf-8');
-        const sourceScript = fs.readFileSync(sourceEntry.scriptPath, 'utf-8');
-        if (normalizeContent(installedScript) !== normalizeContent(sourceScript)) {
-            return false;
-        }
-        const hasInstalledData = !!installedEntry.dataFile;
-        const hasSourceData = !!sourceEntry.dataFile;
-        if (hasInstalledData !== hasSourceData) {
-            return false;
-        }
-        if (hasInstalledData && hasSourceData) {
-            const installedData = fs.readFileSync(installedEntry.dataFile, 'utf-8');
-            const sourceData = fs.readFileSync(sourceEntry.dataFile, 'utf-8');
-            if (normalizeContent(installedData) !== normalizeContent(sourceData)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function listInstalledHooksWithScope(agentId, cwd = process.cwd(), options) {
-    const agent = AGENTS[agentId];
-    if (!agent.supportsHooks) {
-        return [];
-    }
-    const results = [];
-    const seen = new Set();
-    const addHook = (hook, scope, agentId) => {
-        if (seen.has(hook.name))
-            return;
-        results.push({
-            name: hook.name,
-            path: hook.scriptPath,
-            dataFile: hook.dataFile,
-            scope,
-            agent: agentId,
-        });
-        seen.add(hook.name);
-    };
-    // Project-scoped hooks (project .agents overrides agent-specific dirs)
-    const projectDirs = getProjectHooksDirs(agentId, cwd);
-    for (const dir of projectDirs) {
-        const projectHooks = listHookEntriesFromDir(dir);
-        for (const hook of projectHooks) {
-            addHook(hook, 'project', agentId);
-        }
-    }
-    // User-scoped hooks (version-aware when home is provided)
-    const home = options?.home || getEffectiveHome(agentId);
-    const userDir = path.join(home, `.${agentId}`, agent.hooksDir);
-    const userHooks = listHookEntriesFromDir(userDir);
-    for (const hook of userHooks) {
-        addHook(hook, 'user', agentId);
-    }
-    return results;
-}
-export async function installHooks(source, agents, options = {}) {
-    const installed = [];
-    const errors = [];
-    const scope = options.scope || 'user';
-    const cwd = process.cwd();
-    const hooksDir = path.join(source, 'hooks');
-    const hooks = listHookEntriesFromDir(hooksDir);
-    const uniqueAgents = Array.from(new Set(agents));
-    for (const agentId of uniqueAgents) {
-        const agent = AGENTS[agentId];
-        if (!agent || !agent.supportsHooks) {
-            errors.push(`${agentId}:Agent does not support hooks`);
-            continue;
-        }
-        const targetDir = scope === 'project' ? getProjectHooksDirs(agentId, cwd)[0] : getHooksDir(agentId);
-        for (const entry of hooks) {
-            try {
-                copyHook(entry, targetDir);
-                installed.push(`${entry.name}:${agentId}`);
-            }
-            catch (err) {
-                errors.push(`${entry.name}:${agentId}:${err.message}`);
-            }
-        }
-    }
-    return { installed, errors };
-}
-/**
- * Path to the hooks dir of a specific version home (not the active one).
- */
-export function getVersionHooksDir(agent, version) {
-    const home = getVersionHomePath(agent, version);
-    return path.join(home, `.${agent}`, AGENTS[agent].hooksDir);
-}
-/**
- * List hook entries in a specific version home.
- */
-export function listHooksInVersionHome(agent, version) {
-    return listHookEntriesFromDir(getVersionHooksDir(agent, version));
-}
-/**
- * Check if a hook installed in a specific version matches central content.
- */
-function versionHookMatches(agent, version, hookName) {
-    const central = listHookEntriesFromDir(getCentralHooksDir()).find((e) => e.name === hookName);
-    if (!central)
-        return false;
-    const installed = listHooksInVersionHome(agent, version).find((e) => e.name === hookName);
-    if (!installed)
-        return false;
-    try {
-        if (normalizeContent(fs.readFileSync(installed.scriptPath, 'utf-8')) !==
-            normalizeContent(fs.readFileSync(central.scriptPath, 'utf-8'))) {
-            return false;
-        }
-        if (!!installed.dataFile !== !!central.dataFile)
-            return false;
-        if (installed.dataFile && central.dataFile) {
-            if (normalizeContent(fs.readFileSync(installed.dataFile, 'utf-8')) !==
-                normalizeContent(fs.readFileSync(central.dataFile, 'utf-8'))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Compare a version home's hooks against central. Returns the reconciliation diff.
- */
-export function diffVersionHooks(agent, version) {
-    const central = new Set(listHookEntriesFromDir(getCentralHooksDir()).map((e) => e.name));
-    const installed = new Set(listHooksInVersionHome(agent, version).map((e) => e.name));
-    const toAdd = [];
-    const toUpdate = [];
-    const matched = [];
-    const orphans = [];
-    for (const name of central) {
-        if (!installed.has(name)) {
-            toAdd.push(name);
-        }
-        else if (!versionHookMatches(agent, version, name)) {
-            toUpdate.push(name);
-        }
-        else {
-            matched.push(name);
-        }
-    }
-    for (const name of installed) {
-        if (!central.has(name))
-            orphans.push(name);
-    }
-    return { agent, version, toAdd: toAdd.sort(), toUpdate: toUpdate.sort(), matched, orphans: orphans.sort() };
-}
-/**
- * Install a single hook from central into a specific version home.
- */
-export function installHookToVersion(agent, version, hookName) {
-    const central = listHookEntriesFromDir(getCentralHooksDir()).find((e) => e.name === hookName);
-    if (!central) {
-        return { success: false, error: `Hook '${hookName}' not found in central` };
-    }
-    const targetDir = getVersionHooksDir(agent, version);
-    try {
-        fs.mkdirSync(targetDir, { recursive: true });
-        copyHook(central, targetDir);
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-    return { success: true };
-}
-/**
- * Remove a single hook (script + data file) from a specific version home.
- */
-export function removeHookFromVersion(agent, version, hookName) {
-    try {
-        removeHookFiles(getVersionHooksDir(agent, version), hookName);
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-    return { success: true };
-}
-/**
- * Iterate all (agent, version) pairs that support hooks and are installed,
- * optionally scoped to a single agent/version.
- */
-export function iterHooksCapableVersions(filter) {
-    const pairs = [];
-    const hookAgents = HOOKS_CAPABLE_AGENTS;
-    const agents = filter?.agent ? [filter.agent] : hookAgents;
-    for (const agent of agents) {
-        if (!hookAgents.includes(agent))
-            continue;
-        const versions = listInstalledVersions(agent);
-        for (const version of versions) {
-            if (filter?.version && filter.version !== version)
-                continue;
-            pairs.push({ agent, version });
-        }
-    }
-    return pairs;
-}
-export async function removeHook(name, agents) {
-    const removed = [];
-    const errors = [];
-    const uniqueAgents = Array.from(new Set(agents));
-    for (const agentId of uniqueAgents) {
-        const agent = AGENTS[agentId];
-        if (!agent || !agent.supportsHooks) {
-            errors.push(`${agentId}:Agent does not support hooks`);
-            continue;
-        }
-        try {
-            const dir = getHooksDir(agentId);
-            const filesBefore = fs.existsSync(dir) ? fs.readdirSync(dir) : [];
-            removeHookFiles(dir, name);
-            const filesAfter = fs.existsSync(dir) ? fs.readdirSync(dir) : [];
-            if (filesBefore.length !== filesAfter.length) {
-                removed.push(`${name}:${agentId}`);
-            }
-        }
-        catch (err) {
-            errors.push(`${name}:${agentId}:${err.message}`);
-        }
-    }
-    return { removed, errors };
-}
-/**
- * Get detailed info about a hook from central storage.
- */
-export function getHookInfo(name) {
-    const centralDir = getCentralHooksDir();
-    const hookPath = path.join(centralDir, name);
-    if (!fs.existsSync(hookPath)) {
-        return null;
-    }
-    // Read hook content - it could be a file or directory
-    let content = '';
-    const stat = fs.statSync(hookPath);
-    if (stat.isFile()) {
-        content = fs.readFileSync(hookPath, 'utf-8');
-    }
-    else if (stat.isDirectory()) {
-        // For directory hooks, list the files
-        const files = fs.readdirSync(hookPath);
-        content = `Directory hook containing:\n${files.map((f) => `  - ${f}`).join('\n')}`;
-    }
-    return {
-        name,
-        path: hookPath,
-        content,
-    };
-}
-export function discoverHooksFromRepo(repoPath) {
-    const hooksDir = path.join(repoPath, 'hooks');
-    return listHookEntriesFromDir(hooksDir).map((h) => h.name);
-}
-/**
- * Get the source hook entry from repo.
- */
-export function getSourceHookEntry(repoPath, hookName) {
-    const hooksDir = path.join(repoPath, 'hooks');
-    const entries = listHookEntriesFromDir(hooksDir);
-    return entries.find((e) => e.name === hookName) || null;
-}
-/**
- * Install hooks to central ~/.agents/hooks/ directory.
- * Shims will symlink this to per-agent directories for synced agents.
- */
-export async function installHooksCentrally(source) {
-    const installed = [];
-    const errors = [];
-    const centralDir = getCentralHooksDir();
-    if (!fs.existsSync(centralDir)) {
-        fs.mkdirSync(centralDir, { recursive: true });
-    }
-    // Collect all hooks from shared directory
-    const sharedDir = path.join(source, 'hooks');
-    const sharedHooks = listHookEntriesFromDir(sharedDir);
-    for (const entry of sharedHooks) {
-        try {
-            copyHook(entry, centralDir);
-            installed.push(entry.name);
-        }
-        catch (err) {
-            errors.push(`${entry.name}: ${err.message}`);
-        }
-    }
-    return { installed, errors };
-}
-/**
- * List hooks from central ~/.agents/hooks/ directory.
- */
-export function listCentralHooks() {
-    return listHookEntriesFromDir(getCentralHooksDir());
-}
-/**
- * Parse ~/.agents/hooks.yaml manifest.
- * Returns hook definitions with lifecycle event metadata.
- */
-export function parseHookManifest() {
-    const manifestPath = path.join(getAgentsDir(), 'hooks.yaml');
-    if (!fs.existsSync(manifestPath)) {
-        return {};
-    }
-    try {
-        const content = fs.readFileSync(manifestPath, 'utf-8');
-        const parsed = yaml.parse(content);
-        return parsed || {};
-    }
-    catch {
-        return {};
-    }
-}
-// Codex events that support a matcher field (matches tool name or session type).
-// UserPromptSubmit and Stop never include a matcher.
-const CODEX_MATCHER_EVENTS = new Set(['PreToolUse', 'PostToolUse', 'SessionStart']);
-/**
- * Register hooks as lifecycle events in an agent's config.
- * Reads hooks.yaml manifest, merges into the agent's config file(s).
- * Only manages hooks whose command paths are under ~/.agents/hooks/.
- * Does not remove user-added hooks.
- *
- * @param agentsDirOverride - Override the agents dir (used in tests to inject a temp path).
- */
-export function registerHooksToSettings(agentId, versionHome, hookManifest, agentsDirOverride) {
-    const manifest = hookManifest || parseHookManifest();
-    if (Object.keys(manifest).length === 0) {
-        return { registered: [], errors: [] };
-    }
-    const agentsDir = agentsDirOverride ?? getAgentsDir();
-    if (agentId === 'claude') {
-        return registerHooksForClaude(versionHome, manifest, agentsDir);
-    }
-    if (agentId === 'codex') {
-        return registerHooksForCodex(versionHome, manifest, agentsDir);
-    }
-    if (agentId === 'gemini') {
-        return registerHooksForGemini(versionHome, manifest, agentsDir);
-    }
-    return { registered: [], errors: [] };
-}
-/**
- * Gemini has no native UserPromptSubmit event — map it to BeforeAgent,
- * the closest lifecycle phase that fires before the model sees the prompt.
- * Note: gemini's BeforeAgent can only APPEND via additionalContext — it
- * cannot replace the prompt. The hook script branches on caller to emit
- * the correct protocol.
- */
-const GEMINI_EVENT_MAP = {
-    UserPromptSubmit: 'BeforeAgent',
-};
-function registerHooksForClaude(versionHome, manifest, agentsDir) {
-    const registered = [];
-    const errors = [];
-    const configDir = path.join(versionHome, '.claude');
-    const settingsPath = path.join(configDir, 'settings.json');
-    let config = {};
-    if (fs.existsSync(settingsPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        }
-        catch {
-            errors.push('Failed to parse settings.json');
-            return { registered, errors };
-        }
-    }
-    if (!config.hooks || typeof config.hooks !== 'object') {
-        config.hooks = {};
-    }
-    const hooks = config.hooks;
-    // Build set of all command paths the current manifest will register.
-    // Used to garbage-collect stale entries left behind after hook renames.
-    const managedHooksPrefix = path.join(agentsDir, 'hooks') + path.sep;
-    const currentManifestPaths = new Set();
-    for (const hookDef of Object.values(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('claude'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        currentManifestPaths.add(path.join(agentsDir, 'hooks', hookDef.script));
-    }
-    // Remove stale entries: any hook command under ~/.agents/hooks/ that isn't
-    // in the current manifest is a leftover from a renamed/deleted hook script.
-    for (const eventEntries of Object.values(hooks)) {
-        if (!Array.isArray(eventEntries))
-            continue;
-        for (const group of eventEntries) {
-            if (!group.hooks)
-                continue;
-            group.hooks = group.hooks.filter((h) => !h.command.startsWith(managedHooksPrefix) || currentManifestPaths.has(h.command));
-        }
-    }
-    // Remove empty matcher groups left after cleanup
-    for (const [event, eventEntries] of Object.entries(hooks)) {
-        if (!Array.isArray(eventEntries))
-            continue;
-        hooks[event] = eventEntries.filter((g) => g.hooks && g.hooks.length > 0);
-    }
-    for (const [name, hookDef] of Object.entries(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('claude'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        const commandPath = path.join(agentsDir, 'hooks', hookDef.script);
-        if (!fs.existsSync(commandPath)) {
-            errors.push(`${name}: script not found at ${commandPath}`);
-            continue;
-        }
-        for (const event of hookDef.events) {
-            if (!hooks[event]) {
-                hooks[event] = [];
-            }
-            const eventEntries = hooks[event];
-            const matcher = hookDef.matcher || '';
-            const timeout = hookDef.timeout || 600;
-            let matcherGroup = eventEntries.find((e) => (e.matcher || '') === matcher);
-            if (!matcherGroup) {
-                matcherGroup = { matcher, hooks: [] };
-                eventEntries.push(matcherGroup);
-            }
-            if (!matcherGroup.hooks) {
-                matcherGroup.hooks = [];
-            }
-            const existingIdx = matcherGroup.hooks.findIndex((h) => h.command === commandPath);
-            const hookEntry = { type: 'command', command: commandPath, timeout };
-            if (existingIdx >= 0) {
-                matcherGroup.hooks[existingIdx] = hookEntry;
-            }
-            else {
-                matcherGroup.hooks.push(hookEntry);
-            }
-            registered.push(`${name} -> ${event}`);
-        }
-    }
-    try {
-        fs.mkdirSync(configDir, { recursive: true });
-        fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2), 'utf-8');
-    }
-    catch (err) {
-        errors.push(`Failed to write settings.json: ${err.message}`);
-    }
-    return { registered, errors };
-}
-function registerHooksForCodex(versionHome, manifest, agentsDir) {
-    const registered = [];
-    const errors = [];
-    const configDir = path.join(versionHome, '.codex');
-    const hooksPath = path.join(configDir, 'hooks.json');
-    const configPath = path.join(configDir, 'config.toml');
-    // Read existing hooks.json — must have top-level "hooks" wrapper key
-    let hooksFile = { hooks: {} };
-    if (fs.existsSync(hooksPath)) {
-        try {
-            const existing = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
-            if (existing &&
-                typeof existing === 'object' &&
-                !Array.isArray(existing) &&
-                existing.hooks &&
-                typeof existing.hooks === 'object') {
-                hooksFile = existing;
-            }
-        }
-        catch {
-            errors.push('Failed to parse hooks.json');
-            return { registered, errors };
-        }
-    }
-    // Build set of current manifest command paths for codex to GC stale entries
-    const managedHooksPrefix = path.join(agentsDir, 'hooks') + path.sep;
-    const currentManifestPaths = new Set();
-    for (const hookDef of Object.values(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('codex'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        currentManifestPaths.add(path.join(agentsDir, 'hooks', hookDef.script));
-    }
-    // Remove stale entries from all event groups
-    for (const eventGroups of Object.values(hooksFile.hooks)) {
-        for (const group of eventGroups) {
-            if (!group.hooks)
-                continue;
-            group.hooks = group.hooks.filter((h) => !h.command.startsWith(managedHooksPrefix) || currentManifestPaths.has(h.command));
-        }
-    }
-    for (const [event, eventGroups] of Object.entries(hooksFile.hooks)) {
-        hooksFile.hooks[event] = eventGroups.filter((g) => g.hooks && g.hooks.length > 0);
-    }
-    for (const [name, hookDef] of Object.entries(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('codex'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        const commandPath = path.join(agentsDir, 'hooks', hookDef.script);
-        if (!fs.existsSync(commandPath)) {
-            errors.push(`${name}: script not found at ${commandPath}`);
-            continue;
-        }
-        const timeout = hookDef.timeout || 600;
-        for (const event of hookDef.events) {
-            if (!hooksFile.hooks[event]) {
-                hooksFile.hooks[event] = [];
-            }
-            const eventGroups = hooksFile.hooks[event];
-            // PreToolUse / PostToolUse / SessionStart use a matcher field.
-            // UserPromptSubmit / Stop never include a matcher.
-            const usesMatcher = CODEX_MATCHER_EVENTS.has(event);
-            const matcherValue = usesMatcher ? (hookDef.matcher ?? '') : undefined;
-            // Find the group for this matcher (or the sole no-matcher group)
-            let group;
-            if (matcherValue !== undefined) {
-                group = eventGroups.find((g) => (g.matcher ?? '') === matcherValue);
-                if (!group) {
-                    group = matcherValue ? { matcher: matcherValue, hooks: [] } : { hooks: [] };
-                    eventGroups.push(group);
-                }
-            }
-            else {
-                group = eventGroups.find((g) => g.matcher === undefined);
-                if (!group) {
-                    group = { hooks: [] };
-                    eventGroups.push(group);
-                }
-            }
-            if (!group.hooks) {
-                group.hooks = [];
-            }
-            const existingIdx = group.hooks.findIndex((h) => h.command === commandPath);
-            const hookEntry = { type: 'command', command: commandPath, timeout };
-            if (existingIdx >= 0) {
-                group.hooks[existingIdx] = hookEntry;
-            }
-            else {
-                group.hooks.push(hookEntry);
-            }
-            registered.push(`${name} -> ${event}`);
-        }
-    }
-    if (registered.length === 0) {
-        return { registered, errors };
-    }
-    try {
-        fs.mkdirSync(configDir, { recursive: true });
-        fs.writeFileSync(hooksPath, JSON.stringify(hooksFile, null, 2), 'utf-8');
-    }
-    catch (err) {
-        errors.push(`Failed to write hooks.json: ${err.message}`);
-        return { registered, errors };
-    }
-    // Ensure [features] codex_hooks = true in config.toml
-    try {
-        let tomlConfig = {};
-        if (fs.existsSync(configPath)) {
-            try {
-                tomlConfig = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
-            }
-            catch { /* start fresh if corrupt */ }
-        }
-        if (!tomlConfig.features || typeof tomlConfig.features !== 'object') {
-            tomlConfig.features = {};
-        }
-        tomlConfig.features.codex_hooks = true;
-        fs.writeFileSync(configPath, TOML.stringify(tomlConfig), 'utf-8');
-    }
-    catch (err) {
-        errors.push(`Failed to update config.toml: ${err.message}`);
-    }
-    return { registered, errors };
-}
-function registerHooksForGemini(versionHome, manifest, agentsDir) {
-    const registered = [];
-    const errors = [];
-    const configDir = path.join(versionHome, '.gemini');
-    const settingsPath = path.join(configDir, 'settings.json');
-    let config = {};
-    if (fs.existsSync(settingsPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        }
-        catch {
-            errors.push('Failed to parse gemini settings.json');
-            return { registered, errors };
-        }
-    }
-    if (!config.hooks || typeof config.hooks !== 'object') {
-        config.hooks = {};
-    }
-    const hooks = config.hooks;
-    // Build set of current manifest command paths for gemini to GC stale entries
-    const managedHooksPrefix = path.join(agentsDir, 'hooks') + path.sep;
-    const currentManifestPaths = new Set();
-    for (const hookDef of Object.values(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('gemini'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        currentManifestPaths.add(path.join(agentsDir, 'hooks', hookDef.script));
-    }
-    // Remove stale entries
-    for (const eventEntries of Object.values(hooks)) {
-        if (!Array.isArray(eventEntries))
-            continue;
-        for (const group of eventEntries) {
-            if (!group.hooks)
-                continue;
-            group.hooks = group.hooks.filter((h) => !h.command.startsWith(managedHooksPrefix) || currentManifestPaths.has(h.command));
-        }
-    }
-    for (const [event, eventEntries] of Object.entries(hooks)) {
-        if (!Array.isArray(eventEntries))
-            continue;
-        hooks[event] = eventEntries.filter((g) => g.hooks && g.hooks.length > 0);
-    }
-    for (const [name, hookDef] of Object.entries(manifest)) {
-        if (hookDef.agents && !hookDef.agents.includes('gemini'))
-            continue;
-        if (!hookDef.events || hookDef.events.length === 0)
-            continue;
-        const commandPath = path.join(agentsDir, 'hooks', hookDef.script);
-        if (!fs.existsSync(commandPath)) {
-            errors.push(`${name}: script not found at ${commandPath}`);
-            continue;
-        }
-        // Gemini timeouts are in milliseconds; manifest timeouts are seconds.
-        const timeoutMs = (hookDef.timeout || 600) * 1000;
-        for (const event of hookDef.events) {
-            const geminiEvent = GEMINI_EVENT_MAP[event] ?? event;
-            if (!hooks[geminiEvent]) {
-                hooks[geminiEvent] = [];
-            }
-            const eventEntries = hooks[geminiEvent];
-            const matcher = hookDef.matcher || '';
-            let matcherGroup = eventEntries.find((e) => (e.matcher || '') === matcher);
-            if (!matcherGroup) {
-                matcherGroup = { matcher, hooks: [] };
-                eventEntries.push(matcherGroup);
-            }
-            if (!matcherGroup.hooks) {
-                matcherGroup.hooks = [];
-            }
-            const existingIdx = matcherGroup.hooks.findIndex((h) => h.command === commandPath);
-            const hookEntry = { name, type: 'command', command: commandPath, timeout: timeoutMs };
-            if (existingIdx >= 0) {
-                matcherGroup.hooks[existingIdx] = hookEntry;
-            }
-            else {
-                matcherGroup.hooks.push(hookEntry);
-            }
-            registered.push(`${name} -> ${geminiEvent}`);
-        }
-    }
-    try {
-        fs.mkdirSync(configDir, { recursive: true });
-        fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2), 'utf-8');
-    }
-    catch (err) {
-        errors.push(`Failed to write gemini settings.json: ${err.message}`);
-    }
-    return { registered, errors };
-}
-//# sourceMappingURL=hooks.js.map