claude-yolo-extended 1.9.4 → 1.9.5

package/eslint.config.js

@@ -0,0 +1,25 @@
+import js from '@eslint/js';
+import globals from 'globals';
+
+export default [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        ...globals.node
+      }
+    },
+    rules: {
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'no-console': 'off',
+      'prefer-const': 'error',
+      'no-var': 'error',
+      'eqeqeq': ['error', 'always', { null: 'ignore' }]
+    }
+  },
+  {
+    ignores: ['node_modules/**', 'coverage/**']
+  }
+];

package/jest.config.js

@@ -0,0 +1,9 @@
+export default {
+  testEnvironment: 'node',
+  transform: {},
+  moduleFileExtensions: ['js', 'mjs'],
+  testMatch: ['**/tests/**/*.test.js'],
+  collectCoverageFrom: ['lib/**/*.js', 'bin/**/*.js'],
+  coveragePathIgnorePatterns: ['/node_modules/'],
+  verbose: true
+};

package/lib/constants.js

@@ -0,0 +1,97 @@
+/**
+ * Shared constants for claude-yolo-extended
+ */
+
+import os from 'os';
+import path from 'path';
+
+// ANSI color codes for terminal output
+export const COLORS = {
+  RED: '\x1b[31m',
+  YELLOW: '\x1b[33m',
+  CYAN: '\x1b[36m',
+  GREEN: '\x1b[32m',
+  ORANGE: '\x1b[38;5;208m',
+  RESET: '\x1b[0m',
+  BOLD: '\x1b[1m'
+};
+
+// Destructured exports for convenience
+export const { RED, YELLOW, CYAN, GREEN, ORANGE, RESET, BOLD } = COLORS;
+
+// Valid mode values
+export const VALID_MODES = ['yolo', 'safe'];
+
+// Path to persistent state file
+export const STATE_FILE = path.join(os.homedir(), '.claude_yolo_state');
+
+// Path to last update check timestamp file
+export const UPDATE_CHECK_FILE = path.join(os.homedir(), '.claude_yolo_last_update_check');
+
+// Update check interval (24 hours in milliseconds)
+export const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1000;
+
+// Valid commands for the cl wrapper
+export const VALID_COMMANDS = ['/YON', '/YOFF', '/STATUS', '/HELP', '/H', '/?'];
+
+// Dangerous shell characters for Windows command injection prevention
+export const DANGEROUS_CHARS_PATTERN = /[;&|`$><]/;
+
+// Timeouts (in milliseconds)
+export const TIMEOUTS = {
+  NPM_VIEW: 30000, // 30 seconds for npm view
+  NPM_INSTALL: 300000, // 5 minutes for npm install
+  NPM_ROOT: 10000, // 10 seconds for npm -g root
+  DEFAULT: 120000 // 2 minutes default
+};
+
+// Maximum directory traversal depth (security limit)
+export const MAX_TRAVERSAL_DEPTH = 10;
+
+// Error severity levels
+export const ErrorSeverity = {
+  FATAL: 'fatal', // Application must exit
+  ERROR: 'error', // Operation failed but can continue
+  WARNING: 'warning', // Non-critical issue
+  DEBUG: 'debug' // Debug info (only shown with DEBUG env)
+};
+
+/**
+ * Consistent error logging function
+ * @param {string} message - Error message
+ * @param {string} severity - Error severity level
+ * @param {Error} [error] - Optional error object for stack trace
+ */
+export function logError(message, severity = ErrorSeverity.ERROR, error = null) {
+  const prefix =
+    {
+      [ErrorSeverity.FATAL]: `${RED}${BOLD}FATAL:${RESET}`,
+      [ErrorSeverity.ERROR]: `${RED}Error:${RESET}`,
+      [ErrorSeverity.WARNING]: `${YELLOW}Warning:${RESET}`,
+      [ErrorSeverity.DEBUG]: `${CYAN}Debug:${RESET}`
+    }[severity] || `${RED}Error:${RESET}`;
+
+  // Always log to stderr for errors
+  if (severity === ErrorSeverity.DEBUG) {
+    if (process.env.DEBUG) {
+      console.log(`${prefix} ${message}`);
+      if (error?.stack) console.log(error.stack);
+    }
+  } else {
+    console.error(`${prefix} ${message}`);
+    if (process.env.DEBUG && error?.stack) {
+      console.error(error.stack);
+    }
+  }
+}
+
+/**
+ * Handle fatal errors - log and exit
+ * @param {string} message - Error message
+ * @param {Error} [error] - Optional error object
+ * @param {number} [exitCode=1] - Process exit code
+ */
+export function handleFatalError(message, error = null, exitCode = 1) {
+  logError(message, ErrorSeverity.FATAL, error);
+  process.exit(exitCode);
+}

package/package.json

@@ -1,15 +1,31 @@
 {
   "name": "claude-yolo-extended",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "description": "Claude CLI wrapper with YOLO mode (bypass safety) and SAFE mode support, auto-updates, and colorful loading messages",
   "bin": {
     "claude-yolo-extended": "bin/claude-yolo.js",
     "cl": "bin/cl.js"
   },
+  "scripts": {
+    "preuninstall": "node preuninstall.js",
+    "lint": "eslint bin lib",
+    "lint:fix": "eslint bin lib --fix",
+    "format": "prettier --write \"bin/**/*.js\" \"lib/**/*.js\"",
+    "format:check": "prettier --check \"bin/**/*.js\" \"lib/**/*.js\"",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage"
+  },
   "dependencies": {
     "punycode": "latest",
     "@anthropic-ai/claude-code": "2.0.76"
   },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "eslint": "^9.17.0",
+    "globals": "^15.14.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.2"
+  },
   "type": "module",
   "repository": {
     "type": "git",

package/postinstall.js

@@ -1,13 +1,7 @@
 #!/usr/bin/env node
 
 import readline from 'readline';
-
-// ANSI color codes
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const CYAN = '\x1b[36m';
-const RESET = '\x1b[0m';
-const BOLD = '\x1b[1m';
+import { RED, YELLOW, CYAN, GREEN, RESET, BOLD } from './lib/constants.js';
 
 // Create readline interface for user input
 const rl = readline.createInterface({

package/preuninstall.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Preuninstall script for claude-yolo-extended
+ * Cleans up modified CLI files before package removal
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+console.log('Cleaning up claude-yolo-extended files...');
+
+// Files to clean up in each location
+const filesToClean = [
+  'cli-yolo.js',
+  'cli-yolo.mjs',
+  '.claude-yolo-extended-consent'
+];
+
+async function cleanup() {
+  const locations = [];
+
+  // Check local installation
+  try {
+    const localDir = path.join(__dirname, 'node_modules', '@anthropic-ai', 'claude-code');
+    if (fs.existsSync(localDir)) {
+      locations.push(localDir);
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+
+  // Check global installation (async)
+  try {
+    const { stdout } = await execAsync('npm -g root');
+    const globalRoot = stdout.trim();
+    const globalDir = path.join(globalRoot, '@anthropic-ai', 'claude-code');
+    if (fs.existsSync(globalDir)) {
+      locations.push(globalDir);
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+
+  let totalCleaned = 0;
+
+  for (const location of locations) {
+    for (const file of filesToClean) {
+      const filePath = path.join(location, file);
+      try {
+        if (fs.existsSync(filePath)) {
+          fs.unlinkSync(filePath);
+          console.log(`  Removed: ${filePath}`);
+          totalCleaned++;
+        }
+      } catch (err) {
+        console.error(`  Could not remove ${filePath}: ${err.message}`);
+      }
+    }
+  }
+
+  if (totalCleaned > 0) {
+    console.log(`Cleanup complete: removed ${totalCleaned} file(s)`);
+  } else {
+    console.log('No files needed cleanup');
+  }
+}
+
+cleanup().catch(err => {
+  console.error(`Cleanup failed: ${err.message}`);
+});

package/tests/constants.test.js

@@ -0,0 +1,146 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import {
+  COLORS,
+  RED, YELLOW, CYAN, GREEN, ORANGE, RESET, BOLD,
+  VALID_MODES,
+  STATE_FILE,
+  UPDATE_CHECK_FILE,
+  UPDATE_CHECK_INTERVAL,
+  VALID_COMMANDS,
+  DANGEROUS_CHARS_PATTERN,
+  TIMEOUTS,
+  MAX_TRAVERSAL_DEPTH,
+  ErrorSeverity,
+  logError,
+  handleFatalError
+} from '../lib/constants.js';
+import os from 'os';
+import path from 'path';
+
+describe('constants', () => {
+  describe('COLORS', () => {
+    it('should export all color codes', () => {
+      expect(COLORS.RED).toBe('\x1b[31m');
+      expect(COLORS.YELLOW).toBe('\x1b[33m');
+      expect(COLORS.CYAN).toBe('\x1b[36m');
+      expect(COLORS.GREEN).toBe('\x1b[32m');
+      expect(COLORS.ORANGE).toBe('\x1b[38;5;208m');
+      expect(COLORS.RESET).toBe('\x1b[0m');
+      expect(COLORS.BOLD).toBe('\x1b[1m');
+    });
+
+    it('should export destructured color constants', () => {
+      expect(RED).toBe(COLORS.RED);
+      expect(YELLOW).toBe(COLORS.YELLOW);
+      expect(CYAN).toBe(COLORS.CYAN);
+      expect(GREEN).toBe(COLORS.GREEN);
+      expect(ORANGE).toBe(COLORS.ORANGE);
+      expect(RESET).toBe(COLORS.RESET);
+      expect(BOLD).toBe(COLORS.BOLD);
+    });
+  });
+
+  describe('VALID_MODES', () => {
+    it('should contain yolo and safe modes', () => {
+      expect(VALID_MODES).toContain('yolo');
+      expect(VALID_MODES).toContain('safe');
+      expect(VALID_MODES).toHaveLength(2);
+    });
+  });
+
+  describe('STATE_FILE', () => {
+    it('should be in home directory', () => {
+      expect(STATE_FILE).toBe(path.join(os.homedir(), '.claude_yolo_state'));
+    });
+  });
+
+  describe('UPDATE_CHECK_FILE', () => {
+    it('should be in home directory', () => {
+      expect(UPDATE_CHECK_FILE).toBe(path.join(os.homedir(), '.claude_yolo_last_update_check'));
+    });
+  });
+
+  describe('UPDATE_CHECK_INTERVAL', () => {
+    it('should be 24 hours in milliseconds', () => {
+      expect(UPDATE_CHECK_INTERVAL).toBe(24 * 60 * 60 * 1000);
+    });
+  });
+
+  describe('VALID_COMMANDS', () => {
+    it('should contain all valid cl commands', () => {
+      expect(VALID_COMMANDS).toContain('/YON');
+      expect(VALID_COMMANDS).toContain('/YOFF');
+      expect(VALID_COMMANDS).toContain('/STATUS');
+      expect(VALID_COMMANDS).toContain('/HELP');
+      expect(VALID_COMMANDS).toContain('/H');
+      expect(VALID_COMMANDS).toContain('/?');
+    });
+  });
+
+  describe('DANGEROUS_CHARS_PATTERN', () => {
+    it('should match dangerous shell characters', () => {
+      expect(DANGEROUS_CHARS_PATTERN.test(';')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('&')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('|')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('`')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('$')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('>')).toBe(true);
+      expect(DANGEROUS_CHARS_PATTERN.test('<')).toBe(true);
+    });
+
+    it('should not match safe characters', () => {
+      expect(DANGEROUS_CHARS_PATTERN.test('hello')).toBe(false);
+      expect(DANGEROUS_CHARS_PATTERN.test('file.txt')).toBe(false);
+      expect(DANGEROUS_CHARS_PATTERN.test('path/to/file')).toBe(false);
+    });
+  });
+
+  describe('TIMEOUTS', () => {
+    it('should have reasonable timeout values', () => {
+      expect(TIMEOUTS.NPM_VIEW).toBe(30000);
+      expect(TIMEOUTS.NPM_INSTALL).toBe(300000);
+      expect(TIMEOUTS.NPM_ROOT).toBe(10000);
+      expect(TIMEOUTS.DEFAULT).toBe(120000);
+    });
+  });
+
+  describe('MAX_TRAVERSAL_DEPTH', () => {
+    it('should be a reasonable depth limit', () => {
+      expect(MAX_TRAVERSAL_DEPTH).toBe(10);
+    });
+  });
+
+  describe('ErrorSeverity', () => {
+    it('should have all severity levels', () => {
+      expect(ErrorSeverity.FATAL).toBe('fatal');
+      expect(ErrorSeverity.ERROR).toBe('error');
+      expect(ErrorSeverity.WARNING).toBe('warning');
+      expect(ErrorSeverity.DEBUG).toBe('debug');
+    });
+  });
+
+  describe('logError', () => {
+    let consoleSpy;
+    let consoleErrorSpy;
+
+    beforeEach(() => {
+      consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    });
+
+    afterEach(() => {
+      consoleSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should log errors to stderr', () => {
+      logError('test error');
+      expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it('should log warnings to stderr', () => {
+      logError('test warning', ErrorSeverity.WARNING);
+      expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+  });
+});