@veestack-tools/cli 3.0.1 → 3.0.3

package/src/wasm/loader.ts

@@ -1,409 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export interface WasmEngineConfig {
-  apiUrl: string;
-  apiKey: string;
-  licenseKey?: string;
-  sessionId: string;
-}
-
-export interface RemoteRulesResponse {
-  success: boolean;
-  rules_version: string;
-  rules_count: number;
-  encrypted_rules: string;
-  encrypted_session_key: string;
-  expires_at: string;
-  licensed: boolean;
-}
-
-export interface WasmAnalysisResult {
-  findings: WasmFinding[];
-  metrics: WasmMetrics;
-  execution_time_ms: number;
-}
-
-export interface WasmFinding {
-  rule_id: string;
-  file_path: string;
-  line_number: number;
-  severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
-  message: string;
-  context_hash: string;
-}
-
-export interface WasmMetrics {
-  files_scanned: number;
-  rules_applied: number;
-  patterns_matched: number;
-}
-
-export interface WasmSnapshot {
-  version: string;
-  project_id: string;
-  files: WasmFileInfo[];
-  dependencies: WasmDependency[];
-  metadata: WasmMetadata;
-}
-
-export interface WasmFileInfo {
-  path: string;
-  path_hash: string;
-  content_hash: string;
-  extension: string;
-  size_bytes: number;
-  estimated_lines: number;
-  depth: number;
-}
-
-export interface WasmDependency {
-  name_hash: string;
-  version_major: number;
-  version_minor: number;
-  category: 'dev' | 'prod' | 'peer';
-}
-
-export interface WasmMetadata {
-  total_files: number;
-  total_dependencies: number;
-  framework: string;
-  language: string;
-}
-
-export class WasmEngineLoader {
-  private config: WasmEngineConfig;
-  private wasmModule: WebAssembly.Module | null = null;
-  private wasmInstance: WebAssembly.Instance | null = null;
-  private sessionKey: string = '';
-  private rules: any[] = [];
-
-  constructor(config: WasmEngineConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Load and initialize the WASM engine
-   */
-  async initialize(): Promise<boolean> {
-    try {
-      // Find WASM file path
-      const wasmPath = this.findWasmFile();
-      
-      if (!wasmPath) {
-        console.error('❌ WASM engine not found');
-        return false;
-      }
-
-      // Read WASM file
-      const wasmBuffer = fs.readFileSync(wasmPath);
-      
-      // Compile WASM module
-      this.wasmModule = await WebAssembly.compile(wasmBuffer);
-      
-      // Create import object with required imports
-      const importObject = {
-        env: {
-          memory: new WebAssembly.Memory({ initial: 256, maximum: 512 }),
-          __memory_base: 0,
-          __table_base: 0,
-          abort: (msg: number, file: number, line: number, column: number) => {
-            console.error(`WASM abort: ${msg} at ${file}:${line}:${column}`);
-          },
-          // Add console.log for debugging
-          log: (ptr: number, len: number) => {
-            const memory = (this.wasmInstance?.exports.memory as WebAssembly.Memory);
-            if (memory) {
-              const bytes = new Uint8Array(memory.buffer, ptr, len);
-              const message = new TextDecoder().decode(bytes);
-              console.log(`[WASM] ${message}`);
-            }
-          }
-        },
-        console: {
-          log: (message: string) => {
-            console.log(`[WASM Engine] ${message}`);
-          }
-        }
-      };
-
-      // Instantiate WASM module
-      this.wasmInstance = await WebAssembly.instantiate(this.wasmModule, importObject);
-      
-      console.log('✅ WASM engine initialized successfully');
-      return true;
-    } catch (error) {
-      console.error('❌ Failed to initialize WASM engine:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Fetch encrypted rules from remote server
-   */
-  async fetchRemoteRules(framework: string, language: string): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.config.apiUrl}/functions/v1/rules`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.config.apiKey}`
-        },
-        body: JSON.stringify({
-          framework,
-          language,
-          version: '1.0.0',
-          session_id: this.config.sessionId,
-          license_key: this.config.licenseKey
-        })
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        console.error('❌ Failed to fetch rules:', error);
-        return false;
-      }
-
-      const data: RemoteRulesResponse = await response.json();
-      
-      if (!data.success) {
-        console.error('❌ Rules API returned unsuccessful response');
-        return false;
-      }
-
-      // Decrypt session key
-      this.sessionKey = this.decryptSessionKey(data.encrypted_session_key);
-      
-      // Decrypt rules
-      const decryptedRules = this.decryptRules(data.encrypted_rules);
-      this.rules = JSON.parse(decryptedRules);
-      
-      console.log(`✅ Loaded ${this.rules.length} security rules (v${data.rules_version})`);
-      
-      return true;
-    } catch (error) {
-      console.error('❌ Error fetching remote rules:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Analyze a snapshot using WASM engine
-   */
-  async analyzeSnapshot(
-    snapshot: WasmSnapshot,
-    fileContents: Map<string, string>
-  ): Promise<WasmAnalysisResult | null> {
-    if (!this.wasmInstance) {
-      console.error('❌ WASM engine not initialized');
-      return null;
-    }
-
-    try {
-      const exports = this.wasmInstance.exports as any;
-
-      // Initialize session in WASM
-      const encryptedKey = this.encryptString(this.sessionKey);
-      
-      // Convert strings to WASM memory
-      const snapshotJson = JSON.stringify(snapshot);
-      const contentsJson = JSON.stringify(Object.fromEntries(fileContents));
-      
-      // Allocate memory for input
-      const snapshotPtr = this.allocateString(snapshotJson);
-      const contentsPtr = this.allocateString(contentsJson);
-      const sessionPtr = this.allocateString(encryptedKey);
-      
-      // Call WASM functions
-      const initResult = exports.initialize_session(sessionPtr);
-      if (!initResult) {
-        console.error('❌ Failed to initialize WASM session');
-        return null;
-      }
-
-      // Load encrypted rules into WASM
-      const rulesJson = JSON.stringify(this.rules);
-      const encryptedRules = this.encryptString(rulesJson);
-      const rulesPtr = this.allocateString(encryptedRules);
-      
-      const loadResult = exports.load_rules(rulesPtr);
-      if (loadResult !== 0) {
-        console.error('❌ Failed to load rules into WASM');
-        return null;
-      }
-
-      // Run analysis
-      const resultPtr = exports.analyze_snapshot(snapshotPtr, contentsPtr);
-      
-      // Read result from WASM memory
-      const resultJson = this.readString(resultPtr);
-      
-      // Free allocated memory (if WASM exports free function)
-      if (exports.free) {
-        exports.free(snapshotPtr);
-        exports.free(contentsPtr);
-        exports.free(sessionPtr);
-        exports.free(rulesPtr);
-        exports.free(resultPtr);
-      }
-
-      // Parse result
-      const result: WasmAnalysisResult = JSON.parse(resultJson);
-      
-      return result;
-    } catch (error) {
-      console.error('❌ Analysis error:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Validate license key
-   */
-  validateLicense(hardwareId: string): boolean {
-    if (!this.wasmInstance) return false;
-    
-    try {
-      const exports = this.wasmInstance.exports as any;
-      const licensePtr = this.allocateString(this.config.licenseKey || '');
-      const hardwarePtr = this.allocateString(hardwareId);
-      
-      const result = exports.validate_license(licensePtr, hardwarePtr);
-      
-      return result === 1;
-    } catch (error) {
-      console.error('❌ License validation error:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Generate content fingerprint
-   */
-  generateFingerprint(content: string): string {
-    if (!this.wasmInstance) {
-      // Fallback to Node.js crypto
-      return crypto.createHash('sha256').update(content).digest('hex');
-    }
-    
-    try {
-      const exports = this.wasmInstance.exports as any;
-      const contentPtr = this.allocateString(content);
-      const resultPtr = exports.generate_fingerprint(contentPtr);
-      return this.readString(resultPtr);
-    } catch {
-      return crypto.createHash('sha256').update(content).digest('hex');
-    }
-  }
-
-  /**
-   * Generate unique session ID
-   */
-  static generateSessionId(): string {
-    return crypto.randomUUID();
-  }
-
-  /**
-   * Generate hardware fingerprint
-   */
-  static generateHardwareId(): string {
-    const components = [
-      process.platform,
-      process.arch,
-      process.version,
-      require('os').hostname(),
-      'veestack'
-    ];
-    
-    const combined = components.join('|');
-    return crypto.createHash('sha256').update(combined).digest('hex');
-  }
-
-  // Private helper methods
-
-  private findWasmFile(): string | null {
-    // Search for WASM file in multiple locations
-    const possiblePaths = [
-      path.join(__dirname, '../../wasm-engine/target/wasm32-unknown-unknown/release/veestack_wasm_engine.wasm'),
-      path.join(__dirname, '../engine.wasm'),
-      path.join(process.cwd(), 'node_modules/@veestack-tools/wasm-engine/engine.wasm'),
-      path.join(__dirname, '../../../wasm-engine/pkg/veestack_wasm_engine_bg.wasm'),
-    ];
-
-    for (const wasmPath of possiblePaths) {
-      if (fs.existsSync(wasmPath)) {
-        return wasmPath;
-      }
-    }
-
-    return null;
-  }
-
-  private allocateString(str: string): number {
-    if (!this.wasmInstance) return 0;
-    
-    const encoder = new TextEncoder();
-    const bytes = encoder.encode(str + '\0');
-    
-    const exports = this.wasmInstance.exports as any;
-    const ptr = exports.malloc ? exports.malloc(bytes.length) : 0;
-    
-    if (ptr === 0) {
-      // Fallback: use memory directly
-      const memory = exports.memory as WebAssembly.Memory;
-      const view = new Uint8Array(memory.buffer);
-      const offset = 1024; // Use a fixed offset
-      view.set(bytes, offset);
-      return offset;
-    }
-    
-    const memory = exports.memory as WebAssembly.Memory;
-    const view = new Uint8Array(memory.buffer);
-    view.set(bytes, ptr);
-    
-    return ptr;
-  }
-
-  private readString(ptr: number): string {
-    if (!this.wasmInstance) return '';
-    
-    const exports = this.wasmInstance.exports as any;
-    const memory = exports.memory as WebAssembly.Memory;
-    const view = new Uint8Array(memory.buffer);
-    
-    // Find null terminator
-    let end = ptr;
-    while (view[end] !== 0 && end < view.length) {
-      end++;
-    }
-    
-    const bytes = view.slice(ptr, end);
-    return new TextDecoder().decode(bytes);
-  }
-
-  private decryptSessionKey(encrypted: string): string {
-    const decoded = Buffer.from(encrypted, 'base64');
-    return decoded.toString('utf-8');
-  }
-
-  private decryptRules(encrypted: string): string {
-    const decoded = Buffer.from(encrypted, 'base64');
-    const key = Buffer.from(this.sessionKey);
-    
-    const decrypted = decoded.map((byte, i) => byte ^ key[i % key.length]);
-    return decrypted.toString('utf-8');
-  }
-
-  private encryptString(str: string): string {
-    const key = Buffer.from('veestack_session_key_2024');
-    const data = Buffer.from(str);
-    
-    const encrypted = data.map((byte, i) => byte ^ key[i % key.length]);
-    return encrypted.toString('base64');
-  }
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "moduleResolution": "bundler",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm'],
-  dts: false,
-  clean: true,
-  external: ['@veestack/types', '@veestack/engine', '@veestack/utils'],
-  splitting: false,
-  // No banner here - we'll add shebang in package.json bin
-});