@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/bin/onyx-guard.sh

@@ -0,0 +1,251 @@
+#!/usr/bin/env bash
+#
+# ONYX GUARD - Pre-Hook Tool Interceptor
+#
+# Executable shell script that wraps ONYX agent execution
+# and enforces delegation rules via JavaScript interceptor.
+#
+# USAGE:
+#   ./onyx-guard.sh --tool Read --file /path/to/file.js
+#   ./onyx-guard.sh --tool Bash --command "npm install"
+#   ./onyx-guard.sh --check-tool Read
+#
+
+set -euo pipefail
+
+# Colors for terminal output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+DIM='\033[2m'
+RESET='\033[0m'
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LIB_DIR="$(dirname "$SCRIPT_DIR")/lib"
+
+# FORBIDDEN TOOLS for ONYX
+FORBIDDEN_TOOLS=("Read" "Write" "Edit" "Bash" "Grep" "Glob" "NotebookEdit")
+
+# ALLOWED TOOLS for ONYX
+ALLOWED_TOOLS=("Task" "WebFetch" "WebSearch" "TodoWrite" "Skill")
+
+# Check if tool is forbidden
+is_forbidden_tool() {
+  local tool="$1"
+  for forbidden in "${FORBIDDEN_TOOLS[@]}"; do
+    if [[ "$tool" == "$forbidden" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# Check if tool is allowed
+is_allowed_tool() {
+  local tool="$1"
+  for allowed in "${ALLOWED_TOOLS[@]}"; do
+    if [[ "$tool" == "$allowed" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# Block forbidden tool and suggest delegation
+block_tool() {
+  local tool="$1"
+  shift
+  local params="$*"
+
+  echo -e "${RED}"
+  echo "═══════════════════════════════════════════════════════════════════════════════"
+  echo "🚨 ONYX TOOL BLOCK TRIGGERED"
+  echo "═══════════════════════════════════════════════════════════════════════════════"
+  echo -e "${RESET}"
+
+  echo -e "${YELLOW}Agent:${RESET} ONYX"
+  echo -e "${YELLOW}Forbidden Tool:${RESET} ${RED}${tool}${RESET}"
+  echo -e "${YELLOW}Params:${RESET} ${DIM}${params}${RESET}"
+
+  echo ""
+  echo -e "${YELLOW}📋 ONYX DELEGATION RULE:${RESET}"
+  echo -e "${DIM}  ONYX is META-BOSS and NEVER touches files directly${RESET}"
+  echo -e "${DIM}  ONYX delegates to Task tool → Task tool uses file operations${RESET}"
+  echo -e "${RED}  FORBIDDEN: ONYX → ${tool} (direct file access)${RESET}"
+  echo -e "${GREEN}  ALLOWED: ONYX → Task → ${tool} (delegated access)${RESET}"
+
+  echo ""
+  echo -e "${CYAN}✅ DELEGATION MESSAGE:${RESET}"
+
+  case "$tool" in
+    Read)
+      echo -e "${GREEN}Use Task tool: \"Read the file at ${params}\"${RESET}"
+      ;;
+    Write)
+      echo -e "${GREEN}Use Task tool: \"Write content to ${params}\"${RESET}"
+      ;;
+    Edit)
+      echo -e "${GREEN}Use Task tool: \"Edit the file ${params}\"${RESET}"
+      ;;
+    Bash)
+      echo -e "${GREEN}Use Task tool: \"Execute bash command: ${params}\"${RESET}"
+      ;;
+    Grep)
+      echo -e "${GREEN}Use Task tool: \"Search for pattern ${params}\"${RESET}"
+      ;;
+    Glob)
+      echo -e "${GREEN}Use Task tool: \"Find files matching pattern ${params}\"${RESET}"
+      ;;
+    *)
+      echo -e "${GREEN}Use Task tool: \"Execute ${tool} with params ${params}\"${RESET}"
+      ;;
+  esac
+
+  echo ""
+  echo -e "${RED}❌ TOOL CALL BLOCKED${RESET}"
+  echo -e "${YELLOW}⚠️  ONYX must delegate to Task tool instead${RESET}"
+  echo ""
+
+  exit 1
+}
+
+# Allow tool with confirmation
+allow_tool() {
+  local tool="$1"
+  echo -e "${GREEN}✅ Tool ${tool} is allowed for ONYX${RESET}"
+  exit 0
+}
+
+# Main guard logic
+guard_tool() {
+  local tool="$1"
+  shift
+  local params="$*"
+
+  # Check if forbidden
+  if is_forbidden_tool "$tool"; then
+    block_tool "$tool" "$params"
+  fi
+
+  # Check if allowed
+  if is_allowed_tool "$tool"; then
+    allow_tool "$tool"
+  fi
+
+  # Unknown tool - warn but allow
+  echo -e "${YELLOW}⚠️  Unknown tool for ONYX: ${tool}${RESET}"
+  echo -e "${DIM}Allowing by default - add to ALLOWED_TOOLS or FORBIDDEN_TOOLS${RESET}"
+  exit 0
+}
+
+# Check tool status without blocking
+check_tool() {
+  local tool="$1"
+
+  if is_forbidden_tool "$tool"; then
+    echo -e "${RED}FORBIDDEN${RESET}: ${tool} (ONYX must delegate to Task)"
+    exit 1
+  elif is_allowed_tool "$tool"; then
+    echo -e "${GREEN}ALLOWED${RESET}: ${tool}"
+    exit 0
+  else
+    echo -e "${YELLOW}UNKNOWN${RESET}: ${tool}"
+    exit 2
+  fi
+}
+
+# Run JavaScript interceptor
+run_js_interceptor() {
+  if [[ -f "$LIB_DIR/onyx-tool-interceptor.js" ]]; then
+    node -e "
+      import('$LIB_DIR/onyx-tool-interceptor.js').then(module => {
+        const interceptor = module.default;
+        interceptor.printReport();
+      });
+    "
+  else
+    echo -e "${YELLOW}⚠️  JavaScript interceptor not found${RESET}"
+  fi
+}
+
+# Print help
+print_help() {
+  cat << EOF
+${CYAN}ONYX GUARD - Tool Interceptor for ONYX Agent${RESET}
+
+USAGE:
+  onyx-guard.sh --tool <TOOL_NAME> [PARAMS...]
+  onyx-guard.sh --check-tool <TOOL_NAME>
+  onyx-guard.sh --list-forbidden
+  onyx-guard.sh --list-allowed
+  onyx-guard.sh --report
+
+OPTIONS:
+  --tool <NAME>        Guard a tool call (blocks forbidden tools)
+  --check-tool <NAME>  Check if tool is allowed (no blocking)
+  --list-forbidden     List all forbidden tools for ONYX
+  --list-allowed       List all allowed tools for ONYX
+  --report             Show JavaScript interceptor report
+  -h, --help           Show this help message
+
+EXAMPLES:
+  # Block Read tool (forbidden for ONYX)
+  onyx-guard.sh --tool Read --file /path/to/file.js
+
+  # Allow Task tool (allowed for ONYX)
+  onyx-guard.sh --tool Task --description "Search for files"
+
+  # Check if tool is allowed
+  onyx-guard.sh --check-tool Bash
+
+FORBIDDEN TOOLS (ONYX must delegate):
+  Read, Write, Edit, Bash, Grep, Glob, NotebookEdit
+
+ALLOWED TOOLS (ONYX can use directly):
+  Task, WebFetch, WebSearch, TodoWrite, Skill
+
+DELEGATION RULE:
+  ONYX is META-BOSS and NEVER touches files directly.
+  ONYX delegates to Task tool → Task tool uses file operations.
+
+EOF
+}
+
+# Parse command line arguments
+case "${1:-}" in
+  --tool)
+    shift
+    guard_tool "$@"
+    ;;
+  --check-tool)
+    shift
+    check_tool "$1"
+    ;;
+  --list-forbidden)
+    echo -e "${RED}FORBIDDEN TOOLS FOR ONYX:${RESET}"
+    for tool in "${FORBIDDEN_TOOLS[@]}"; do
+      echo -e "  ${RED}✗${RESET} $tool"
+    done
+    ;;
+  --list-allowed)
+    echo -e "${GREEN}ALLOWED TOOLS FOR ONYX:${RESET}"
+    for tool in "${ALLOWED_TOOLS[@]}"; do
+      echo -e "  ${GREEN}✓${RESET} $tool"
+    done
+    ;;
+  --report)
+    run_js_interceptor
+    ;;
+  -h|--help)
+    print_help
+    ;;
+  *)
+    echo -e "${RED}Error: Invalid arguments${RESET}"
+    echo ""
+    print_help
+    exit 1
+    ;;
+esac

package/bin/prompts.js

@@ -0,0 +1,284 @@
+/**
+ * Interactive Prompts for Boss Claude Setup Wizard
+ * Beautiful CLI prompts using readline and chalk
+ */
+
+import readline from 'readline';
+import chalk from 'chalk';
+
+/**
+ * Create readline interface
+ */
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Ask a question and get user input
+ */
+export function ask(question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+
+    const prompt = defaultValue
+      ? `${question} ${chalk.dim(`(${defaultValue})`)}: `
+      : `${question}: `;
+
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+/**
+ * Ask a yes/no question
+ */
+export function confirm(question, defaultYes = true) {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+
+    const hint = defaultYes ? chalk.dim('(Y/n)') : chalk.dim('(y/N)');
+    const prompt = `${question} ${hint}: `;
+
+    rl.question(prompt, (answer) => {
+      rl.close();
+
+      const normalized = answer.trim().toLowerCase();
+
+      if (!normalized) {
+        resolve(defaultYes);
+        return;
+      }
+
+      resolve(normalized === 'y' || normalized === 'yes');
+    });
+  });
+}
+
+/**
+ * Ask for password/secret (hidden input)
+ */
+export function askSecret(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+
+    // Disable echo for password input
+    const stdin = process.stdin;
+    const setRawMode = stdin.setRawMode;
+
+    let input = '';
+
+    rl.question(`${question}: `, () => {
+      // This won't be called due to raw mode
+    });
+
+    if (setRawMode) {
+      stdin.setRawMode(true);
+    }
+
+    stdin.on('data', (char) => {
+      const str = char.toString('utf-8');
+
+      // Handle Enter key
+      if (str === '\n' || str === '\r' || str === '\r\n') {
+        stdin.removeAllListeners('data');
+        if (setRawMode) {
+          stdin.setRawMode(false);
+        }
+        rl.close();
+        process.stdout.write('\n');
+        resolve(input);
+        return;
+      }
+
+      // Handle Ctrl+C
+      if (str === '\u0003') {
+        process.exit();
+      }
+
+      // Handle backspace
+      if (str === '\u007f' || str === '\b') {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+        return;
+      }
+
+      // Add character to input and show asterisk
+      input += str;
+      process.stdout.write('*');
+    });
+  });
+}
+
+/**
+ * Show a spinner while executing async operation
+ */
+export async function spinner(message, asyncFn) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+
+  process.stdout.write(`${message} ${frames[0]}`);
+
+  const intervalId = setInterval(() => {
+    i = (i + 1) % frames.length;
+    process.stdout.write(`\r${message} ${chalk.cyan(frames[i])}`);
+  }, 80);
+
+  try {
+    const result = await asyncFn();
+    clearInterval(intervalId);
+    process.stdout.write(`\r${message} ${chalk.green('✓')}\n`);
+    return { success: true, result };
+  } catch (error) {
+    clearInterval(intervalId);
+    process.stdout.write(`\r${message} ${chalk.red('✗')}\n`);
+    return { success: false, error };
+  }
+}
+
+/**
+ * Display a section header
+ */
+export function header(title, description = '') {
+  console.log('\n' + chalk.bold.blue('━'.repeat(60)));
+  console.log(chalk.bold.white(title));
+  if (description) {
+    console.log(chalk.dim(description));
+  }
+  console.log(chalk.bold.blue('━'.repeat(60)) + '\n');
+}
+
+/**
+ * Display a success message
+ */
+export function success(message) {
+  console.log(chalk.green('✓') + ' ' + message);
+}
+
+/**
+ * Display an error message
+ */
+export function error(message, details = '') {
+  console.log(chalk.red('✗') + ' ' + message);
+  if (details) {
+    console.log(chalk.dim('  ' + details));
+  }
+}
+
+/**
+ * Display a warning message
+ */
+export function warning(message) {
+  console.log(chalk.yellow('⚠') + ' ' + message);
+}
+
+/**
+ * Display an info message
+ */
+export function info(message) {
+  console.log(chalk.blue('ℹ') + ' ' + message);
+}
+
+/**
+ * Display a list of items
+ */
+export function list(items, style = 'bullet') {
+  items.forEach((item, idx) => {
+    const prefix = style === 'numbered'
+      ? chalk.dim(`${idx + 1}.`)
+      : chalk.dim('•');
+    console.log(`  ${prefix} ${item}`);
+  });
+}
+
+/**
+ * Display a progress bar
+ */
+export function progress(current, total, label = '') {
+  const percentage = Math.round((current / total) * 100);
+  const filled = Math.round((current / total) * 30);
+  const empty = 30 - filled;
+
+  const bar = chalk.green('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+  const text = label ? `${label} ` : '';
+
+  process.stdout.write(`\r${text}[${bar}] ${percentage}%`);
+
+  if (current === total) {
+    process.stdout.write('\n');
+  }
+}
+
+/**
+ * Clear the screen
+ */
+export function clear() {
+  process.stdout.write('\x1Bc');
+}
+
+/**
+ * Display a box with content
+ */
+export function box(content, title = '') {
+  const lines = content.split('\n');
+  const maxLength = Math.max(...lines.map(l => l.length), title.length);
+  const width = Math.min(maxLength + 4, 60);
+
+  console.log('\n' + chalk.dim('┌' + '─'.repeat(width - 2) + '┐'));
+
+  if (title) {
+    const padding = Math.floor((width - title.length - 4) / 2);
+    console.log(chalk.dim('│') + ' '.repeat(padding) + chalk.bold(title) + ' '.repeat(width - padding - title.length - 3) + chalk.dim('│'));
+    console.log(chalk.dim('├' + '─'.repeat(width - 2) + '┤'));
+  }
+
+  lines.forEach(line => {
+    const paddedLine = line + ' '.repeat(width - line.length - 3);
+    console.log(chalk.dim('│') + ' ' + paddedLine + chalk.dim('│'));
+  });
+
+  console.log(chalk.dim('└' + '─'.repeat(width - 2) + '┘') + '\n');
+}
+
+/**
+ * Choose from a list of options
+ */
+export async function choose(question, options) {
+  console.log(chalk.bold(question) + '\n');
+
+  options.forEach((option, idx) => {
+    console.log(chalk.dim(`  ${idx + 1}.`) + ` ${option}`);
+  });
+
+  console.log();
+
+  while (true) {
+    const answer = await ask('Enter your choice (1-' + options.length + ')');
+    const choice = parseInt(answer);
+
+    if (choice >= 1 && choice <= options.length) {
+      return { index: choice - 1, value: options[choice - 1] };
+    }
+
+    error('Invalid choice. Please try again.');
+  }
+}
+
+/**
+ * Pause and wait for user to press Enter
+ */
+export function pause(message = 'Press Enter to continue...') {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+    rl.question(chalk.dim(message), () => {
+      rl.close();
+      resolve();
+    });
+  });
+}

package/bin/rollback.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * BOSS CLAUDE - Rollback CLI
+ * Undo setup changes safely
+ */
+
+import { RollbackManager } from '../lib/setup/rollback.js';
+import chalk from 'chalk';
+
+const args = process.argv.slice(2);
+
+// Parse command line arguments
+const options = {
+  verbose: args.includes('--verbose') || args.includes('-v'),
+  dryRun: args.includes('--dry-run') || args.includes('-d'),
+  force: args.includes('--force') || args.includes('-f'),
+  confirm: args.includes('--confirm') || args.includes('-y'),
+  help: args.includes('--help') || args.includes('-h')
+};
+
+// Show help
+if (options.help || args.includes('help')) {
+  console.log(chalk.bold.cyan('\n🔄 BOSS CLAUDE ROLLBACK\n'));
+  console.log(chalk.white('Safely undo setup changes\n'));
+  console.log(chalk.bold('Usage:\n'));
+  console.log(chalk.white('  boss-claude rollback [options]\n'));
+  console.log(chalk.bold('Options:\n'));
+  console.log(chalk.white('  --confirm, -y      Confirm rollback without prompts'));
+  console.log(chalk.white('  --dry-run, -d      Show what would be rolled back (no changes)'));
+  console.log(chalk.white('  --force, -f        Force rollback even if setup completed'));
+  console.log(chalk.white('  --verbose, -v      Show detailed progress'));
+  console.log(chalk.white('  --help, -h         Show this help message\n'));
+  console.log(chalk.bold('Examples:\n'));
+  console.log(chalk.gray('  # Preview rollback'));
+  console.log(chalk.cyan('  boss-claude rollback --dry-run\n'));
+  console.log(chalk.gray('  # Execute rollback'));
+  console.log(chalk.cyan('  boss-claude rollback --confirm\n'));
+  console.log(chalk.gray('  # Force rollback with verbose output'));
+  console.log(chalk.cyan('  boss-claude rollback --force --verbose\n'));
+  process.exit(0);
+}
+
+// Execute rollback
+async function main() {
+  const manager = new RollbackManager(options);
+
+  if (!options.confirm && !options.dryRun) {
+    // Interactive mode
+    const result = await manager.rollbackInteractive();
+
+    if (result.requiresConfirmation) {
+      console.log(chalk.yellow('Add --confirm to execute rollback\n'));
+      process.exit(0);
+    }
+
+    if (result.success) {
+      process.exit(0);
+    } else {
+      process.exit(1);
+    }
+  }
+
+  // Execute rollback
+  const result = await manager.rollback();
+
+  if (result.success) {
+    console.log(chalk.green.bold('✓ Rollback completed successfully\n'));
+    process.exit(0);
+  } else {
+    console.log(chalk.red.bold('✗ Rollback failed\n'));
+    if (result.error) {
+      console.log(chalk.red(result.error + '\n'));
+    }
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error(chalk.red.bold('\n✗ Rollback error\n'));
+  console.error(chalk.red(error.message));
+  if (options.verbose && error.stack) {
+    console.error(chalk.gray('\n' + error.stack));
+  }
+  process.exit(1);
+});