myaidev-method 0.2.19 → 0.2.23

package/src/scripts/security/environment-detect.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+
+/**
+ * MyAIDev Method - Security Environment Detection
+ *
+ * Detects execution environment and recommends setup approach
+ * @module security/environment-detect
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+/**
+ * Environment types
+ */
+const EnvType = {
+  KALI_NATIVE: 'kali_native',
+  KALI_DOCKER: 'kali_docker',
+  UBUNTU_NATIVE: 'ubuntu_native',
+  DEBIAN_NATIVE: 'debian_native',
+  FEDORA_NATIVE: 'fedora_native',
+  DOCKER_CONTAINER: 'docker_container',
+  UNKNOWN: 'unknown'
+};
+
+/**
+ * Environment detection class
+ */
+class EnvironmentDetector {
+  constructor() {
+    this.osInfo = {};
+    this.containerInfo = {};
+    this.toolsInfo = {};
+  }
+
+  /**
+   * Detect execution environment
+   */
+  async detect() {
+    console.log('🔍 Detecting security testing environment...\n');
+
+    // Detect OS
+    this.detectOS();
+
+    // Detect container environment
+    this.detectContainer();
+
+    // Check Docker availability
+    this.detectDocker();
+
+    // Check existing tools
+    this.detectTools();
+
+    // Generate recommendation
+    const recommendation = this.generateRecommendation();
+
+    // Display results
+    this.displayResults(recommendation);
+
+    return {
+      os: this.osInfo,
+      container: this.containerInfo,
+      tools: this.toolsInfo,
+      recommendation
+    };
+  }
+
+  /**
+   * Detect operating system
+   */
+  detectOS() {
+    try {
+      // Check if /etc/os-release exists
+      if (fs.existsSync('/etc/os-release')) {
+        const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+
+        // Parse OS release file
+        const lines = osRelease.split('\n');
+        for (const line of lines) {
+          const [key, value] = line.split('=');
+          if (value) {
+            this.osInfo[key] = value.replace(/"/g, '');
+          }
+        }
+
+        // Determine OS type
+        const id = this.osInfo.ID || '';
+        if (id.includes('kali')) {
+          this.osInfo.type = EnvType.KALI_NATIVE;
+        } else if (id.includes('ubuntu')) {
+          this.osInfo.type = EnvType.UBUNTU_NATIVE;
+        } else if (id.includes('debian')) {
+          this.osInfo.type = EnvType.DEBIAN_NATIVE;
+        } else if (id.includes('fedora') || id.includes('rhel') || id.includes('centos')) {
+          this.osInfo.type = EnvType.FEDORA_NATIVE;
+        } else {
+          this.osInfo.type = EnvType.UNKNOWN;
+        }
+      }
+
+      // Get kernel version
+      try {
+        this.osInfo.kernel = execSync('uname -r', { encoding: 'utf8' }).trim();
+      } catch (err) {
+        this.osInfo.kernel = 'unknown';
+      }
+
+      // Detect package manager
+      if (this.commandExists('apt')) {
+        this.osInfo.packageManager = 'apt';
+      } else if (this.commandExists('dnf')) {
+        this.osInfo.packageManager = 'dnf';
+      } else if (this.commandExists('yum')) {
+        this.osInfo.packageManager = 'yum';
+      } else if (this.commandExists('pacman')) {
+        this.osInfo.packageManager = 'pacman';
+      } else {
+        this.osInfo.packageManager = 'unknown';
+      }
+
+    } catch (err) {
+      console.error('Error detecting OS:', err.message);
+      this.osInfo.type = EnvType.UNKNOWN;
+    }
+  }
+
+  /**
+   * Detect container environment
+   */
+  detectContainer() {
+    try {
+      // Check for /.dockerenv
+      if (fs.existsSync('/.dockerenv')) {
+        this.containerInfo.isContainer = true;
+        this.containerInfo.type = 'docker';
+        return;
+      }
+
+      // Check cgroup for docker/container
+      if (fs.existsSync('/proc/1/cgroup')) {
+        const cgroup = fs.readFileSync('/proc/1/cgroup', 'utf8');
+        if (cgroup.includes('docker')) {
+          this.containerInfo.isContainer = true;
+          this.containerInfo.type = 'docker';
+          return;
+        }
+        if (cgroup.includes('kubepods')) {
+          this.containerInfo.isContainer = true;
+          this.containerInfo.type = 'kubernetes';
+          return;
+        }
+      }
+
+      this.containerInfo.isContainer = false;
+    } catch (err) {
+      this.containerInfo.isContainer = false;
+    }
+  }
+
+  /**
+   * Detect Docker availability
+   */
+  detectDocker() {
+    try {
+      if (this.commandExists('docker')) {
+        const version = execSync('docker --version', { encoding: 'utf8' }).trim();
+        this.containerInfo.dockerAvailable = true;
+        this.containerInfo.dockerVersion = version;
+
+        // Check if Docker daemon is running
+        try {
+          execSync('docker ps', { encoding: 'utf8', stdio: 'ignore' });
+          this.containerInfo.dockerRunning = true;
+        } catch (err) {
+          this.containerInfo.dockerRunning = false;
+        }
+      } else {
+        this.containerInfo.dockerAvailable = false;
+      }
+    } catch (err) {
+      this.containerInfo.dockerAvailable = false;
+    }
+  }
+
+  /**
+   * Detect existing security tools
+   */
+  detectTools() {
+    const essentialTools = [
+      'nmap',
+      'masscan',
+      'sqlmap',
+      'nikto',
+      'hydra',
+      'john',
+      'hashcat',
+      'metasploit-framework',
+      'burpsuite',
+      'zaproxy'
+    ];
+
+    const commandMap = {
+      'metasploit-framework': 'msfconsole',
+      'burpsuite': 'burpsuite',
+      'zaproxy': 'zaproxy'
+    };
+
+    const installed = [];
+    const missing = [];
+
+    for (const tool of essentialTools) {
+      const command = commandMap[tool] || tool;
+      if (this.commandExists(command)) {
+        installed.push(tool);
+      } else {
+        missing.push(tool);
+      }
+    }
+
+    this.toolsInfo.installed = installed;
+    this.toolsInfo.missing = missing;
+    this.toolsInfo.installCount = installed.length;
+    this.toolsInfo.totalCount = essentialTools.length;
+    this.toolsInfo.percentInstalled = Math.round((installed.length / essentialTools.length) * 100);
+  }
+
+  /**
+   * Check if command exists
+   */
+  commandExists(command) {
+    try {
+      execSync(`which ${command}`, { stdio: 'ignore' });
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Generate setup recommendation
+   */
+  generateRecommendation() {
+    const rec = {
+      approach: '',
+      reason: '',
+      steps: [],
+      estimatedTime: '',
+      diskSpace: ''
+    };
+
+    // If already Kali Linux
+    if (this.osInfo.type === EnvType.KALI_NATIVE) {
+      rec.approach = 'verify_tools';
+      rec.reason = 'Kali Linux detected - most tools pre-installed';
+      rec.steps = [
+        'Update package lists: sudo apt update',
+        'Upgrade packages: sudo apt upgrade',
+        'Verify tool installations',
+        'Install any missing tools'
+      ];
+      rec.estimatedTime = '10-15 minutes';
+      rec.diskSpace = '~500MB';
+      return rec;
+    }
+
+    // If Kali Docker available
+    if (this.containerInfo.dockerAvailable && this.containerInfo.dockerRunning) {
+      rec.approach = 'kali_docker';
+      rec.reason = 'Docker available - isolated environment recommended';
+      rec.steps = [
+        'Pull Kali Linux Docker image',
+        'Create persistent volume',
+        'Start Kali container with capabilities',
+        'Install kali-linux-default package',
+        'Verify tool installations'
+      ];
+      rec.estimatedTime = '20-30 minutes';
+      rec.diskSpace = '~3GB';
+      return rec;
+    }
+
+    // If Docker available but not running
+    if (this.containerInfo.dockerAvailable && !this.containerInfo.dockerRunning) {
+      rec.approach = 'kali_docker';
+      rec.reason = 'Docker installed but not running';
+      rec.steps = [
+        'Start Docker service: sudo systemctl start docker',
+        'Pull Kali Linux Docker image',
+        'Create persistent volume',
+        'Start Kali container',
+        'Install security tools'
+      ];
+      rec.estimatedTime = '25-35 minutes';
+      rec.diskSpace = '~3GB';
+      return rec;
+    }
+
+    // Native installation (no Docker)
+    if (this.osInfo.type === EnvType.UBUNTU_NATIVE ||
+        this.osInfo.type === EnvType.DEBIAN_NATIVE) {
+      rec.approach = 'native_install';
+      rec.reason = 'Native Linux installation - direct tool installation';
+      rec.steps = [
+        'Update package lists',
+        'Install network scanning tools (nmap, masscan)',
+        'Install web testing tools (sqlmap, nikto)',
+        'Install exploitation tools (metasploit)',
+        'Install password tools (john, hashcat, hydra)',
+        'Verify installations'
+      ];
+      rec.estimatedTime = '45-60 minutes';
+      rec.diskSpace = '~2GB';
+      return rec;
+    }
+
+    // Fedora/RHEL/CentOS
+    if (this.osInfo.type === EnvType.FEDORA_NATIVE) {
+      rec.approach = 'native_install';
+      rec.reason = 'Fedora/RHEL system - native installation with DNF';
+      rec.steps = [
+        'Enable EPEL repository',
+        'Update system: sudo dnf update',
+        'Install security tools via DNF',
+        'Install remaining tools from source',
+        'Verify installations'
+      ];
+      rec.estimatedTime = '45-60 minutes';
+      rec.diskSpace = '~2GB';
+      return rec;
+    }
+
+    // Fallback - recommend Docker
+    rec.approach = 'install_docker_first';
+    rec.reason = 'Unknown environment - Docker installation recommended';
+    rec.steps = [
+      'Install Docker: curl -fsSL https://get.docker.com | sh',
+      'Start Docker service',
+      'Follow Kali Docker setup',
+      'Install security tools in container'
+    ];
+    rec.estimatedTime = '30-45 minutes';
+    rec.diskSpace = '~3.5GB';
+    return rec;
+  }
+
+  /**
+   * Display detection results
+   */
+  displayResults(recommendation) {
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('🔍 Environment Detection Results');
+    console.log('═══════════════════════════════════════════════════════\n');
+
+    // OS Information
+    console.log('📋 Operating System:');
+    console.log(`   Name: ${this.osInfo.NAME || 'Unknown'}`);
+    console.log(`   Version: ${this.osInfo.VERSION || 'Unknown'}`);
+    console.log(`   ID: ${this.osInfo.ID || 'Unknown'}`);
+    console.log(`   Kernel: ${this.osInfo.kernel || 'Unknown'}`);
+    console.log(`   Package Manager: ${this.osInfo.packageManager || 'Unknown'}\n`);
+
+    // Container Information
+    console.log('🐳 Container Environment:');
+    console.log(`   Running in Container: ${this.containerInfo.isContainer ? 'Yes' : 'No'}`);
+    if (this.containerInfo.isContainer) {
+      console.log(`   Container Type: ${this.containerInfo.type}`);
+    }
+    console.log(`   Docker Available: ${this.containerInfo.dockerAvailable ? 'Yes' : 'No'}`);
+    if (this.containerInfo.dockerAvailable) {
+      console.log(`   Docker Version: ${this.containerInfo.dockerVersion}`);
+      console.log(`   Docker Running: ${this.containerInfo.dockerRunning ? 'Yes' : 'No'}`);
+    }
+    console.log();
+
+    // Security Tools
+    console.log('🛠️  Security Tools:');
+    console.log(`   Installed: ${this.toolsInfo.installCount}/${this.toolsInfo.totalCount} (${this.toolsInfo.percentInstalled}%)`);
+    if (this.toolsInfo.installed.length > 0) {
+      console.log(`   Found: ${this.toolsInfo.installed.slice(0, 5).join(', ')}${this.toolsInfo.installed.length > 5 ? '...' : ''}`);
+    }
+    console.log();
+
+    // Recommendation
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('📋 Recommended Setup Approach');
+    console.log('═══════════════════════════════════════════════════════\n');
+    console.log(`✨ Approach: ${recommendation.approach.toUpperCase().replace(/_/g, ' ')}`);
+    console.log(`📝 Reason: ${recommendation.reason}`);
+    console.log(`⏱️  Estimated Time: ${recommendation.estimatedTime}`);
+    console.log(`💾 Disk Space: ${recommendation.diskSpace}\n`);
+
+    console.log('📝 Setup Steps:');
+    recommendation.steps.forEach((step, index) => {
+      console.log(`   ${index + 1}. ${step}`);
+    });
+    console.log();
+
+    console.log('═══════════════════════════════════════════════════════\n');
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const detector = new EnvironmentDetector();
+  const result = await detector.detect();
+
+  // Save results to JSON for programmatic use
+  const outputPath = '/tmp/security-env-detect.json';
+  fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+  console.log(`📄 Results saved to: ${outputPath}\n`);
+
+  process.exit(0);
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(err => {
+    console.error('❌ Error:', err.message);
+    process.exit(1);
+  });
+}
+
+export { EnvironmentDetector, EnvType };

package/src/scripts/wordpress/publish-to-wordpress.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Publish markdown content to WordPress
+ *
+ * Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import matter from "gray-matter";
+import dotenv from "dotenv";
+import { marked } from "marked";
+import { GutenbergConverter } from "../../mcp/gutenberg-converter.js";
+import { WordPressMCP } from "../../mcp/wordpress-integration.js";
+
+// Load environment variables
+dotenv.config();
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const filePath = args[0];
+const statusIndex = args.indexOf("--status");
+const requestedStatus =
+	statusIndex !== -1 && args[statusIndex + 1] ? args[statusIndex + 1] : "draft";
+
+if (!filePath) {
+	console.error("Error: File path is required");
+	console.error(
+		"Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]",
+	);
+	process.exit(1);
+}
+
+// Validate WordPress configuration
+if (
+	!process.env.WORDPRESS_URL ||
+	!process.env.WORDPRESS_USERNAME ||
+	!process.env.WORDPRESS_APP_PASSWORD
+) {
+	console.error("Error: WordPress configuration is incomplete");
+	console.error("Required environment variables:");
+	console.error("  - WORDPRESS_URL");
+	console.error("  - WORDPRESS_USERNAME");
+	console.error("  - WORDPRESS_APP_PASSWORD");
+	console.error(
+		"\nRun /myai-configure wordpress to set up your WordPress connection",
+	);
+	process.exit(1);
+}
+
+async function publishToWordPress() {
+	try {
+		// Read and parse markdown file
+		const absolutePath = resolve(filePath);
+		const fileContent = readFileSync(absolutePath, "utf-8");
+		const { data: frontmatter, content } = matter(fileContent);
+
+		console.log("📄 Processing file:", filePath);
+		console.log("📋 Title:", frontmatter.title || "No title");
+
+		// Extract interactive blocks before markdown conversion
+		// const { markdown: cleanMarkdown, interactiveBlocks } =
+		// 	GutenbergConverter.extractInteractiveBlocks(content);
+
+		// if (interactiveBlocks.length > 0) {
+		// 	console.log(
+		// 		`   Interactive blocks: ${interactiveBlocks.length} found`,
+		// 	);
+		// }
+
+		// Convert markdown to HTML using marked (preserves placeholders)
+		const html = marked.parse(content);
+
+		// Convert HTML to Gutenberg blocks
+		let htmlContent = GutenbergConverter.htmlToGutenberg(html);
+
+		// Restore interactive blocks as raw HTML blocks
+		// if (interactiveBlocks.length > 0) {
+		// 	htmlContent = GutenbergConverter.restoreInteractiveBlocks(
+		// 		htmlContent,
+		// 		interactiveBlocks,
+		// 	);
+		// }
+
+		// Prepare WordPress configuration
+		const config = {
+			endpoint: {
+				url: process.env.WORDPRESS_URL,
+				api_version: "wp/v2",
+				authentication: {
+					username: process.env.WORDPRESS_USERNAME,
+					password: process.env.WORDPRESS_APP_PASSWORD,
+				},
+			},
+			defaults: {
+				post_status: requestedStatus,
+				format: "standard",
+				comment_status: "open",
+				ping_status: "open",
+			},
+		};
+
+		// Initialize WordPress client
+		const wp = new WordPressMCP(config);
+
+		// Prepare post data
+		const postParams = {
+			title: frontmatter.title || "Untitled",
+			content: htmlContent,
+			status: requestedStatus,
+			excerpt: frontmatter.meta_description || "",
+			slug: frontmatter.slug || "",
+			use_gutenberg: process.env.USE_GUTENBERG === "true",
+			// Note: Tags and categories require ID mapping which will be added in future versions
+		};
+
+		console.log("🚀 Publishing to WordPress...");
+		console.log("   URL:", process.env.WORDPRESS_URL);
+		console.log("   Status:", requestedStatus);
+		console.log(
+			"   Format:",
+			postParams.use_gutenberg ? "Gutenberg" : "Classic",
+		);
+
+		// Create the post
+		const result = await wp.createPost(postParams);
+
+		// Success!
+		console.log("\n✅ Successfully published to WordPress!");
+		console.log("\n📄 Post Details:");
+		console.log("   Post ID:", result.id);
+		console.log("   Title:", result.title.rendered);
+		console.log("   Status:", result.status);
+		console.log("   Slug:", result.slug);
+
+		console.log("\n🔗 URLs:");
+		console.log("   View:", result.link);
+		console.log(
+			"   Edit:",
+			`${process.env.WORDPRESS_URL}/wp-admin/post.php?post=${result.id}&action=edit`,
+		);
+
+		return result;
+	} catch (error) {
+		console.error("\n❌ Error publishing to WordPress:");
+		console.error(error.message);
+
+		if (error.message.includes("401")) {
+			console.error("\n🔑 Authentication failed. Please check:");
+			console.error("   1. Your WordPress username is correct");
+			console.error("   2. Your Application Password is valid");
+			console.error("   3. Application Passwords are enabled on your site");
+		} else if (error.message.includes("404")) {
+			console.error("\n🌐 WordPress site not found. Please check:");
+			console.error("   1. Your WORDPRESS_URL is correct");
+			console.error("   2. The site is accessible");
+			console.error("   3. The REST API is enabled");
+		}
+
+		process.exit(1);
+	}
+}
+
+// Run the publisher
+publishToWordPress();

package/src/server/auth/services/TokenService.ts

@@ -6,7 +6,7 @@ import { AuthError, JWTPayload } from "../../../shared/types.js";
 const TOKEN_EXPIRY_DAYS = 7;
 const ALGORITHM = "RS256";
 
-let keyPair: { publicKey: jose.KeyLike; privateKey: jose.KeyLike } | null = null;
+let keyPair: { publicKey: jose.CryptoKey; privateKey: jose.CryptoKey } | null = null;
 
 export class TokenService extends Context.Tag("TokenService")<
   TokenService,