@automagik/genie 0.260202.530 → 0.260202.1607

package/src/lib/hook-script.ts

@@ -1,263 +0,0 @@
-/**
- * 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
-
-# Don't wrap commands that are already term exec calls (avoid infinite recursion)
-if [[ "$COMMAND" == *"term exec "* ]] || [[ "$COMMAND" == *"/term.js exec"* ]] || [[ "$COMMAND" == *".local/bin/term "* ]] || [[ "$COMMAND" == *".genie/bin/term"* ]]; 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
-# Uses full path since Claude's subprocess may not have full PATH
-WRAPPED_COMMAND="\$HOME/.local/bin/term exec ${sessionName}:\\\${CLAUDIO_SESSION:-claude} '\${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

@@ -1,72 +0,0 @@
-/**
- * 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

@@ -1,163 +0,0 @@
-/**
- * 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)
-  );
-}

package/src/lib/hooks/presets/audited.ts

@@ -1,191 +0,0 @@
-/**
- * Audited Hook Preset
- *
- * Logs all tool executions to a file for later review.
- * Uses PostToolUse hooks to capture tool inputs and outputs.
- *
- * Usage:
- *   const hooks = auditedHooks({ logPath: '~/.genie/audit.log' });
- */
-
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { homedir } from 'os';
-import type { AuditedConfig } from '../../../types/genie-config.js';
-import type { HookConfig, HookInput, HookOutput } from './collaborative.js';
-
-export interface AuditedHookConfig {
-  logPath: string;
-}
-
-/**
- * Default configuration for audited hooks
- */
-export const DEFAULT_AUDITED_CONFIG: AuditedHookConfig = {
-  logPath: '~/.genie/audit.log',
-};
-
-/**
- * Expand ~ to home directory
- */
-function expandTilde(path: string): string {
-  if (path.startsWith('~/')) {
-    return homedir() + path.slice(1);
-  }
-  if (path === '~') {
-    return homedir();
-  }
-  return path;
-}
-
-/**
- * Format a tool input/output for logging
- * Truncates very long values to avoid log bloat
- */
-function formatForLog(value: unknown, maxLength: number = 1000): string {
-  try {
-    const str = JSON.stringify(value);
-    if (str.length > maxLength) {
-      return str.slice(0, maxLength) + '...[truncated]';
-    }
-    return str;
-  } catch {
-    return String(value);
-  }
-}
-
-/**
- * Audit log entry
- */
-interface AuditEntry {
-  timestamp: string;
-  tool: string;
-  input: unknown;
-  response?: unknown;
-  duration_ms?: number;
-}
-
-/**
- * Append an entry to the audit log
- */
-function appendToLog(logPath: string, entry: AuditEntry): void {
-  const expandedPath = resolve(expandTilde(logPath));
-  const dir = dirname(expandedPath);
-
-  // Ensure directory exists
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  const logLine = JSON.stringify({
-    ...entry,
-    input: formatForLog(entry.input),
-    response: entry.response ? formatForLog(entry.response) : undefined,
-  }) + '\n';
-
-  appendFileSync(expandedPath, logLine, 'utf-8');
-}
-
-// Track tool start times for duration calculation
-const toolStartTimes = new Map<string, number>();
-
-/**
- * Create audited hooks configuration
- *
- * This hook captures all tool executions using PostToolUse hooks and
- * logs them to a file in JSONL format for later review.
- */
-export function auditedHooks(config: Partial<AuditedConfig> = {}): HookConfig {
-  const logPath = config.logPath || DEFAULT_AUDITED_CONFIG.logPath;
-
-  return {
-    PreToolUse: [
-      {
-        // Match all tools
-        matcher: /.*/,
-        timeout: 10,
-        hooks: [
-          async (input: HookInput, toolUseID, _options): Promise<HookOutput> => {
-            // Record start time for duration calculation
-            if (toolUseID) {
-              toolStartTimes.set(toolUseID, Date.now());
-            }
-            return { continue: true };
-          },
-        ],
-      },
-    ],
-    PostToolUse: [
-      {
-        // Match all tools
-        matcher: /.*/,
-        timeout: 10,
-        hooks: [
-          async (input: HookInput, toolUseID, _options): Promise<HookOutput> => {
-            // Type guard - only process PostToolUse events
-            if (input.hook_event_name !== 'PostToolUse') {
-              return { continue: true };
-            }
-
-            // Calculate duration if we have a start time
-            let duration_ms: number | undefined;
-            if (toolUseID && toolStartTimes.has(toolUseID)) {
-              duration_ms = Date.now() - toolStartTimes.get(toolUseID)!;
-              toolStartTimes.delete(toolUseID);
-            }
-
-            const entry: AuditEntry = {
-              timestamp: new Date().toISOString(),
-              tool: input.tool_name || 'unknown',
-              input: input.tool_input,
-              response: input.tool_response,
-              duration_ms,
-            };
-
-            try {
-              appendToLog(logPath, entry);
-            } catch (error) {
-              // Don't fail the tool call if logging fails
-              console.warn(`Audit log warning: ${error}`);
-            }
-
-            return { continue: true };
-          },
-        ],
-      },
-    ],
-  };
-}
-
-/**
- * Read the audit log as an array of entries
- * Useful for analysis and review
- */
-export function readAuditLog(logPath: string = DEFAULT_AUDITED_CONFIG.logPath): AuditEntry[] {
-  const expandedPath = resolve(expandTilde(logPath));
-
-  if (!existsSync(expandedPath)) {
-    return [];
-  }
-
-  const { readFileSync } = require('fs');
-  const content = readFileSync(expandedPath, 'utf-8');
-  const lines = content.trim().split('\n').filter(Boolean);
-
-  return lines.map((line: string) => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      return { error: 'parse_failed', raw: line };
-    }
-  });
-}
-
-/**
- * Clear the audit log
- */
-export function clearAuditLog(logPath: string = DEFAULT_AUDITED_CONFIG.logPath): void {
-  const expandedPath = resolve(expandTilde(logPath));
-  const { writeFileSync } = require('fs');
-  writeFileSync(expandedPath, '', 'utf-8');
-}