@automagik/genie 0.260201.2240

package/src/lib/hook-manager.ts

@@ -0,0 +1,130 @@
+import { executeTmux } from './tmux.js';
+
+export interface TmuxHook {
+  event: string;
+  command: string;
+}
+
+/**
+ * Set a tmux hook for a specific event
+ */
+export async function setHook(event: string, command: string): Promise<void> {
+  await executeTmux(`set-hook -g ${event} '${command.replace(/'/g, "'\\''")}'`);
+}
+
+/**
+ * Remove a tmux hook
+ */
+export async function removeHook(event: string): Promise<void> {
+  await executeTmux(`set-hook -gu ${event}`);
+}
+
+/**
+ * List all tmux hooks
+ * Note: tmux doesn't have a direct way to list hooks, so we query common hooks
+ */
+export async function listHooks(): Promise<TmuxHook[]> {
+  // Common tmux hooks
+  const commonHooks = [
+    'after-bind-key',
+    'after-capture-pane',
+    'after-copy-mode',
+    'after-display-message',
+    'after-display-panes',
+    'after-kill-pane',
+    'after-list-buffers',
+    'after-list-clients',
+    'after-list-keys',
+    'after-list-panes',
+    'after-list-sessions',
+    'after-list-windows',
+    'after-load-buffer',
+    'after-lock-server',
+    'after-new-session',
+    'after-new-window',
+    'after-paste-buffer',
+    'after-pipe-pane',
+    'after-queue',
+    'after-refresh-client',
+    'after-rename-session',
+    'after-rename-window',
+    'after-resize-pane',
+    'after-resize-window',
+    'after-save-buffer',
+    'after-select-layout',
+    'after-select-pane',
+    'after-select-window',
+    'after-send-keys',
+    'after-set-buffer',
+    'after-set-environment',
+    'after-set-option',
+    'after-show-environment',
+    'after-show-messages',
+    'after-show-options',
+    'after-split-window',
+    'after-unbind-key',
+    'alert-activity',
+    'alert-bell',
+    'alert-silence',
+    'client-attached',
+    'client-detached',
+    'client-resized',
+    'client-session-changed',
+    'pane-died',
+    'pane-exited',
+    'pane-focus-in',
+    'pane-focus-out',
+    'pane-mode-changed',
+    'pane-set-clipboard',
+    'session-closed',
+    'session-created',
+    'session-renamed',
+    'session-window-changed',
+    'window-linked',
+    'window-pane-changed',
+    'window-renamed',
+    'window-unlinked',
+  ];
+
+  const hooks: TmuxHook[] = [];
+
+  // Query each hook to see if it's set
+  for (const event of commonHooks) {
+    try {
+      const command = await executeTmux(`show-hooks -g ${event}`);
+      if (command.trim()) {
+        // Parse the output (format: "event command")
+        const parts = command.trim().split(' ');
+        if (parts.length >= 2) {
+          hooks.push({
+            event: parts[0],
+            command: parts.slice(1).join(' '),
+          });
+        }
+      }
+    } catch (error) {
+      // Hook not set, continue
+      continue;
+    }
+  }
+
+  return hooks;
+}
+
+/**
+ * Get a specific hook's command
+ */
+export async function getHook(event: string): Promise<string | null> {
+  try {
+    const command = await executeTmux(`show-hooks -g ${event}`);
+    if (command.trim()) {
+      const parts = command.trim().split(' ');
+      if (parts.length >= 2) {
+        return parts.slice(1).join(' ');
+      }
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}

package/src/lib/hook-script.ts

@@ -0,0 +1,256 @@
+/**
+ * Hook Script Manager
+ *
+ * Generates and manages the bash hook script at ~/.claude/hooks/genie-bash-hook.sh
+ * This script intercepts Bash tool calls and rewrites them to go through term exec.
+ */
+
+import { existsSync, unlinkSync, writeFileSync, chmodSync } from 'fs';
+import {
+  ensureClaudeHooksDir,
+  getGenieHookScriptPath,
+  contractClaudePath,
+} from './claude-settings.js';
+import { loadGenieConfig } from './genie-config.js';
+
+/**
+ * Check if the hook script exists
+ */
+export function hookScriptExists(): boolean {
+  return existsSync(getGenieHookScriptPath());
+}
+
+/**
+ * Get the hook script path (re-export for convenience)
+ */
+export function getHookScriptPath(): string {
+  return getGenieHookScriptPath();
+}
+
+/**
+ * Get the hook script path for display (with ~ for home)
+ */
+export function getHookScriptDisplayPath(): string {
+  return contractClaudePath(getGenieHookScriptPath());
+}
+
+/**
+ * Generate the hook script content
+ *
+ * The script:
+ * 1. Reads JSON from stdin (Claude Code sends hook event)
+ * 2. Extracts the command from the Bash tool input
+ * 3. Wraps the command in `term exec genie:shell '...'`
+ * 4. Outputs JSON in Claude Code's expected format
+ */
+export async function generateHookScript(): Promise<string> {
+  // Load config to get session/window names
+  const config = await loadGenieConfig();
+  const sessionName = config.hooks.collaborative?.sessionName || 'genie';
+  const windowName = config.hooks.collaborative?.windowName || 'shell';
+  const target = `${sessionName}:${windowName}`;
+
+  // The bash script that will be executed by Claude Code
+  // Uses jq to parse and transform the JSON
+  const script = `#!/bin/bash
+#
+# Genie Bash Hook for Claude Code
+#
+# This hook intercepts Bash tool calls and rewrites them to execute
+# through tmux via 'term exec', making all terminal operations visible
+# in a shared tmux session.
+#
+# Generated by: genie hooks install
+# Target session: ${target}
+#
+
+# Read the entire input from stdin
+INPUT=$(cat)
+
+# Extract the tool name to verify this is a Bash call
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty')
+
+# If not a Bash tool call, allow it to proceed unchanged
+if [ "$TOOL_NAME" != "Bash" ]; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Extract the command from the tool input
+COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
+
+# If no command, allow it (shouldn't happen but be safe)
+if [ -z "$COMMAND" ]; then
+  echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow"}}'
+  exit 0
+fi
+
+# Escape single quotes in the command for safe shell embedding
+# Replace ' with '\\'\\''
+ESCAPED_COMMAND=$(echo "$COMMAND" | sed "s/'/'\\\\'\\\\''/" )
+
+# Build the wrapped command that goes through term exec
+WRAPPED_COMMAND="term exec ${target} '\${ESCAPED_COMMAND}'"
+
+# Extract other fields from the original input to preserve them
+TIMEOUT=$(echo "$INPUT" | jq -r '.tool_input.timeout // empty')
+DESCRIPTION=$(echo "$INPUT" | jq -r '.tool_input.description // empty')
+RUN_IN_BACKGROUND=$(echo "$INPUT" | jq -r '.tool_input.run_in_background // empty')
+
+# Build the updated input object
+UPDATED_INPUT=$(jq -n \\
+  --arg cmd "$WRAPPED_COMMAND" \\
+  --arg timeout "$TIMEOUT" \\
+  --arg desc "$DESCRIPTION" \\
+  --arg background "$RUN_IN_BACKGROUND" \\
+  '{
+    command: $cmd,
+    timeout: (if $timeout != "" then ($timeout | tonumber) else null end),
+    description: (if $desc != "" then ("[term] " + $desc) else null end),
+    run_in_background: (if $background == "true" then true elif $background == "false" then false else null end)
+  } | with_entries(select(.value != null))')
+
+# Output the hook response in the correct format
+jq -n \\
+  --argjson updatedInput "$UPDATED_INPUT" \\
+  '{
+    "hookSpecificOutput": {
+      "hookEventName": "PreToolUse",
+      "permissionDecision": "allow",
+      "updatedInput": $updatedInput,
+      "additionalContext": "Human can observe: tmux attach -t ${sessionName}"
+    }
+  }'
+`;
+
+  return script;
+}
+
+/**
+ * Write the hook script to disk
+ */
+export async function writeHookScript(): Promise<void> {
+  ensureClaudeHooksDir();
+
+  const scriptPath = getGenieHookScriptPath();
+  const scriptContent = await generateHookScript();
+
+  writeFileSync(scriptPath, scriptContent, 'utf-8');
+
+  // Make the script executable
+  chmodSync(scriptPath, 0o755);
+}
+
+/**
+ * Remove the hook script from disk
+ */
+export function removeHookScript(): void {
+  const scriptPath = getGenieHookScriptPath();
+  if (existsSync(scriptPath)) {
+    unlinkSync(scriptPath);
+  }
+}
+
+/**
+ * Test the hook script with sample input
+ * Returns { success: boolean, output?: string, error?: string }
+ */
+export async function testHookScript(): Promise<{
+  success: boolean;
+  output?: string;
+  error?: string;
+}> {
+  const scriptPath = getGenieHookScriptPath();
+
+  if (!existsSync(scriptPath)) {
+    return {
+      success: false,
+      error: 'Hook script not found. Run "genie hooks install" first.',
+    };
+  }
+
+  // Sample input that mimics what Claude Code sends
+  const sampleInput = JSON.stringify({
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Bash',
+    tool_input: {
+      command: 'echo "Hello, World!"',
+      description: 'Test command',
+    },
+  });
+
+  try {
+    const { $ } = await import('bun');
+
+    // Run the script with sample input
+    const result = await $`echo ${sampleInput} | ${scriptPath}`.quiet();
+
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        error: `Script exited with code ${result.exitCode}`,
+        output: result.stderr.toString(),
+      };
+    }
+
+    const output = result.stdout.toString().trim();
+
+    // Try to parse the output as JSON
+    try {
+      const parsed = JSON.parse(output);
+
+      // Validate the structure
+      if (!parsed.hookSpecificOutput) {
+        return {
+          success: false,
+          error: 'Output missing hookSpecificOutput field',
+          output,
+        };
+      }
+
+      if (parsed.hookSpecificOutput.hookEventName !== 'PreToolUse') {
+        return {
+          success: false,
+          error: 'Output has wrong hookEventName',
+          output,
+        };
+      }
+
+      if (!['allow', 'deny', 'ask'].includes(parsed.hookSpecificOutput.permissionDecision)) {
+        return {
+          success: false,
+          error: 'Output has invalid permissionDecision',
+          output,
+        };
+      }
+
+      // Check that the command was wrapped
+      if (parsed.hookSpecificOutput.updatedInput?.command) {
+        const cmd = parsed.hookSpecificOutput.updatedInput.command;
+        if (!cmd.includes('term exec')) {
+          return {
+            success: false,
+            error: 'Command was not wrapped with term exec',
+            output,
+          };
+        }
+      }
+
+      return {
+        success: true,
+        output,
+      };
+    } catch (parseError: any) {
+      return {
+        success: false,
+        error: `Output is not valid JSON: ${parseError.message}`,
+        output,
+      };
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: `Failed to run hook script: ${error.message}`,
+    };
+  }
+}

package/src/lib/hooks/compose.ts

@@ -0,0 +1,72 @@
+/**
+ * Hook Composition Utilities
+ *
+ * Functions for merging multiple hook configurations together.
+ */
+
+import type { HookConfig } from './presets/collaborative.js';
+
+/**
+ * Deep merge two hook configurations
+ *
+ * Hooks are composed by concatenating their hook arrays.
+ * This means all hooks from both configs will run in order.
+ */
+export function mergeHooks(base: HookConfig, override: HookConfig): HookConfig {
+  const result: HookConfig = { ...base };
+
+  // Merge PreToolUse hooks
+  if (override.PreToolUse) {
+    result.PreToolUse = [...(base.PreToolUse || []), ...override.PreToolUse];
+  }
+
+  // Merge PostToolUse hooks
+  if (override.PostToolUse) {
+    result.PostToolUse = [...(base.PostToolUse || []), ...override.PostToolUse];
+  }
+
+  // Merge PermissionRequest hooks
+  if (override.PermissionRequest) {
+    result.PermissionRequest = [...(base.PermissionRequest || []), ...override.PermissionRequest];
+  }
+
+  return result;
+}
+
+/**
+ * Compose multiple hook configurations into one
+ *
+ * Hooks are executed in the order they appear in the array.
+ * First preset's hooks run first.
+ */
+export function composeHooks(...configs: HookConfig[]): HookConfig {
+  return configs.reduce((acc, config) => mergeHooks(acc, config), {});
+}
+
+/**
+ * Check if a hook config is empty (no hooks defined)
+ */
+export function isEmptyHookConfig(config: HookConfig): boolean {
+  return (
+    (!config.PreToolUse || config.PreToolUse.length === 0) &&
+    (!config.PostToolUse || config.PostToolUse.length === 0) &&
+    (!config.PermissionRequest || config.PermissionRequest.length === 0)
+  );
+}
+
+/**
+ * Count total number of hooks in a config
+ */
+export function countHooks(config: HookConfig): number {
+  let count = 0;
+  if (config.PreToolUse) {
+    count += config.PreToolUse.reduce((sum, entry) => sum + entry.hooks.length, 0);
+  }
+  if (config.PostToolUse) {
+    count += config.PostToolUse.reduce((sum, entry) => sum + entry.hooks.length, 0);
+  }
+  if (config.PermissionRequest) {
+    count += config.PermissionRequest.reduce((sum, entry) => sum + entry.hooks.length, 0);
+  }
+  return count;
+}

package/src/lib/hooks/index.ts

@@ -0,0 +1,163 @@
+/**
+ * Hook Preset Library
+ *
+ * Provides reusable hook configurations that can be composed
+ * to enforce agent behaviors architecturally (without prompting).
+ *
+ * Usage:
+ *   import { loadHooksFromConfig, presets, composeHooks } from './hooks';
+ *
+ *   // Load hooks based on genie config
+ *   const hooks = await loadHooksFromConfig();
+ *
+ *   // Or compose manually
+ *   const hooks = composeHooks(
+ *     presets.collaborative(),
+ *     presets.audited({ logPath: '~/.genie/audit.log' })
+ *   );
+ */
+
+import { loadGenieConfig } from '../genie-config.js';
+import type {
+  GenieConfig,
+  PresetName,
+  CollaborativeConfig,
+  SupervisedConfig,
+  SandboxedConfig,
+  AuditedConfig,
+} from '../../types/genie-config.js';
+
+// Re-export types
+export type { HookConfig, HookCallback, HookInput, HookOutput } from './presets/collaborative.js';
+
+// Re-export utilities
+export { mergeHooks, composeHooks, isEmptyHookConfig, countHooks } from './compose.js';
+export { escapeForSingleQuotes, escapeForDoubleQuotes, singleQuote, doubleQuote } from './utils/escape.js';
+
+// Import presets
+import { collaborativeHooks, type CollaborativeHookConfig } from './presets/collaborative.js';
+import { supervisedHooks, type SupervisedHookConfig } from './presets/supervised.js';
+import { sandboxedHooks, type SandboxedHookConfig } from './presets/sandboxed.js';
+import { auditedHooks, type AuditedHookConfig } from './presets/audited.js';
+
+// Re-export preset types
+export type { CollaborativeHookConfig } from './presets/collaborative.js';
+export type { SupervisedHookConfig } from './presets/supervised.js';
+export type { SandboxedHookConfig } from './presets/sandboxed.js';
+export type { AuditedHookConfig } from './presets/audited.js';
+
+// Import compose utilities
+import { composeHooks } from './compose.js';
+import type { HookConfig } from './presets/collaborative.js';
+
+/**
+ * All available presets as functions
+ */
+export const presets = {
+  collaborative: collaborativeHooks,
+  supervised: supervisedHooks,
+  sandboxed: sandboxedHooks,
+  audited: auditedHooks,
+} as const;
+
+/**
+ * Preset factory type
+ */
+export type PresetFactory = typeof presets[PresetName];
+
+/**
+ * Load hooks from genie config file
+ *
+ * Reads ~/.genie/config.json and builds a combined hook configuration
+ * from all enabled presets.
+ *
+ * @returns Combined hook configuration from all enabled presets
+ */
+export async function loadHooksFromConfig(): Promise<HookConfig> {
+  const config = await loadGenieConfig();
+  return buildHooksFromConfig(config);
+}
+
+/**
+ * Build hooks from a genie config object
+ *
+ * This is useful for testing or when you already have the config loaded.
+ */
+export function buildHooksFromConfig(config: GenieConfig): HookConfig {
+  const enabledPresets = config.hooks.enabled;
+
+  if (enabledPresets.length === 0) {
+    return {};
+  }
+
+  const hookConfigs: HookConfig[] = [];
+
+  for (const presetName of enabledPresets) {
+    const presetConfig = config.hooks[presetName] || {};
+    const presetFactory = presets[presetName];
+
+    if (presetFactory) {
+      hookConfigs.push(presetFactory(presetConfig as any));
+    }
+  }
+
+  return composeHooks(...hookConfigs);
+}
+
+/**
+ * Get a human-readable description of the enabled hooks
+ */
+export function describeEnabledHooks(config: GenieConfig): string[] {
+  const descriptions: string[] = [];
+
+  for (const presetName of config.hooks.enabled) {
+    switch (presetName) {
+      case 'collaborative': {
+        const collabConfig: Partial<CollaborativeConfig> = config.hooks.collaborative || {};
+        const session = collabConfig.sessionName || 'genie';
+        const window = collabConfig.windowName || 'shell';
+        descriptions.push(`Collaborative: Bash → term exec ${session}:${window}`);
+        break;
+      }
+      case 'supervised': {
+        const supervisedConfig: Partial<SupervisedConfig> = config.hooks.supervised || {};
+        const tools = supervisedConfig.alwaysAsk || ['Write', 'Edit'];
+        descriptions.push(`Supervised: ${tools.join(', ')} require approval`);
+        break;
+      }
+      case 'sandboxed': {
+        const sandboxConfig: Partial<SandboxedConfig> = config.hooks.sandboxed || {};
+        const paths = sandboxConfig.allowedPaths || ['~/projects', '/tmp'];
+        descriptions.push(`Sandboxed: Restricted to ${paths.join(', ')}`);
+        break;
+      }
+      case 'audited': {
+        const auditConfig: Partial<AuditedConfig> = config.hooks.audited || {};
+        const logPath = auditConfig.logPath || '~/.genie/audit.log';
+        descriptions.push(`Audited: Logging to ${logPath}`);
+        break;
+      }
+    }
+  }
+
+  return descriptions;
+}
+
+/**
+ * Check if any hooks are enabled
+ */
+export function hasEnabledHooks(config: GenieConfig): boolean {
+  return config.hooks.enabled.length > 0;
+}
+
+/**
+ * Parse hook names from a comma-separated string
+ */
+export function parseHookNames(input: string): PresetName[] {
+  const validPresets: PresetName[] = ['collaborative', 'supervised', 'sandboxed', 'audited'];
+  const names = input.split(',').map((s) => s.trim().toLowerCase());
+
+  return names.filter((name): name is PresetName =>
+    validPresets.includes(name as PresetName)
+  );
+}