fix: make wasmtime and wasm_component paths optional in file_ops

The file_ops wrapper was requiring wasmtime_path and wasm_component_path
in the config, but not all uses of file_ops need the WASM component. For
example, Rust wit-bindgen extraction only needs pure file operations.

Changes:
- Removed requirement for wasmtime_path and wasm_component_path
- These are now optional and only used if WASM component execution is needed
- Cleaned up dead code that tried to execute wasmtime with WASM component
- File operations are now handled directly in Go (already was working this way)

This allows file_ops to work for both:
1. Go module workspace preparation (uses file ops only)
2. Potential future WASM component work (could use wasmtime if needed)

Tests: All file_ops use cases continue to work

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: avrabe

tools/file_ops/main.go

@@ -63,132 +63,22 @@ func main() {
 		log.Fatalf("Failed to parse config file: %v", err)
 	}
 
-	// Get wasmtime path from config (provided by Bazel)
-	// The path may be relative to the sandbox root, try to resolve it
-	wasmtimeBinary := config.WasmtimePath
-	if wasmtimeBinary == "" {
-		log.Fatalf("wasmtime_path not specified in config")
-	}
-
-	// Try to find wasmtime - may need to resolve relative path
-	wasmtimeResolved := wasmtimeBinary
-	if _, err := os.Stat(wasmtimeResolved); err != nil {
-		// Try looking in common locations
-		alternativePaths := []string{
-			"wasmtime",
-			"./wasmtime",
-			filepath.Join(filepath.Dir(os.Args[0]), "wasmtime"),
-		}
-		found := false
-		for _, path := range alternativePaths {
-			if _, err := os.Stat(path); err == nil {
-				wasmtimeResolved = path
-				found = true
-				break
-			}
-		}
-		if !found {
-			log.Fatalf("Wasmtime binary not found at %s or alternative locations: %v", wasmtimeBinary, err)
-		}
-	}
-
-	wasmtimeBinary = wasmtimeResolved
-
-	// Get WASM component path from config (provided by Bazel)
-	wasmComponentPath := config.WasmComponentPath
-	if wasmComponentPath == "" {
-		log.Fatalf("wasm_component_path not specified in config")
-	}
-
-	// Try to find component - may need to resolve relative path
-	componentResolved := wasmComponentPath
-	if _, err := os.Stat(componentResolved); err != nil {
-		// Try looking in common locations
-		alternativePaths := []string{
-			"file_ops_component.wasm",
-			"./file_ops_component.wasm",
-			filepath.Join(filepath.Dir(os.Args[0]), "file_ops_component.wasm"),
-		}
-		found := false
-		for _, path := range alternativePaths {
-			if _, err := os.Stat(path); err == nil {
-				componentResolved = path
-				found = true
-				break
-			}
-		}
-		if !found {
-			log.Fatalf("WASM component not found at %s or alternative locations: %v", wasmComponentPath, err)
-		}
-	}
-
-	wasmComponentPath = componentResolved
+	// Note: wasmtime_path and wasm_component_path are optional - they're only needed
+	// if the config uses WASM component execution. File-only operations don't need them.
+	// This file_ops wrapper now handles pure file operations directly in Go.
 
-	// Build wasmtime command - map current working directory (Bazel sandbox root) to /
-	// This gives the WASM component access to all Bazel-provided inputs
-	var args []string
-	args = append(args, "run")
-
-	// Map current directory to / in WASI sandbox
-	// This way, all paths in the Bazel sandbox are accessible with the same relative paths
 	cwd, err := os.Getwd()
 	if err != nil {
 		log.Fatalf("Failed to get current working directory: %v", err)
 	}
 
-	// Map the entire Bazel sandbox with read/write permissions
-	args = append(args, "--dir", cwd+"::/")
-
-	// Convert workspace_dir to absolute path for WASI
+	// Convert workspace_dir to absolute path
 	workspaceFullPath := filepath.Join(cwd, config.WorkspaceDir)
 	if err := os.MkdirAll(workspaceFullPath, 0755); err != nil {
 		log.Fatalf("Failed to create workspace directory: %v", err)
 	}
-	log.Printf("DEBUG: Created workspace directory: %s", workspaceFullPath)
-
-	// Copy config file to a simple location in /tmp that we can pass to WASM component
-	// This avoids symlink issues in Bazel's complex sandbox
-	tmpConfigPath := "/tmp/file_ops_config.json"
-	if err := ioutil.WriteFile(tmpConfigPath, configData, 0644); err != nil {
-		log.Fatalf("Failed to write temporary config file: %v", err)
-	}
-	log.Printf("DEBUG: Wrote config to temp file: %s", tmpConfigPath)
-
-	// Map /tmp directory for config access
-	args = append(args, "--dir", "/tmp::/"+"tmp")
-
-	// Explicitly map the workspace directory with write permissions
-	args = append(args, "--dir", workspaceFullPath+"::"+"/workspace")
-
-	// Execute WASM component via wasmtime
-	log.Printf("DEBUG: Executing file_ops WASM component")
-	log.Printf("DEBUG: Wasmtime: %s", wasmtimeBinary)
-	log.Printf("DEBUG: Component: %s", wasmComponentPath)
-	log.Printf("DEBUG: Workspace dir: %s", config.WorkspaceDir)
-	log.Printf("DEBUG: Operations count: %d", len(config.Operations))
-
-	// Use the explicitly mapped workspace directory in WASI
-	// We mapped workspaceFullPath to /workspace
-	// The directory already exists from the Go wrapper, so the WASM component just needs to use it
-	wasiWorkspaceDir := "/workspace"
-	log.Printf("DEBUG: WASI workspace dir: %s (already created in Go wrapper)", wasiWorkspaceDir)
-
-	// Update config to use the mapped workspace directory
-	// The WASM component should treat this as already-existing
-	config.WorkspaceDir = wasiWorkspaceDir
-
-	// Write updated config to temp file
-	updatedConfigData, err := json.Marshal(config)
-	if err != nil {
-		log.Fatalf("Failed to marshal updated config: %v", err)
-	}
-	if err := ioutil.WriteFile("/tmp/file_ops_config.json", updatedConfigData, 0644); err != nil {
-		log.Fatalf("Failed to write updated config file: %v", err)
-	}
-	log.Printf("DEBUG: Updated config with absolute workspace path")
 
 	// Process file operations directly in Go
-	// This is more reliable than trying to use the WASM component for now
 	log.Printf("DEBUG: Processing %d file operations", len(config.Operations))
 
 	for i, op := range config.Operations {