🔧 Port Go file operations to TinyGo with WIT bindings

[avrabe]

Overview

Port the existing Go file operations from tools/file_ops/main.go in rules_wasm_component to TinyGo with proper WIT interface bindings.

Tasks

• Create TinyGo module structure and go.mod
• Port JSON batch processing functionality
• Port individual file operations (copy_file, mkdir, etc.)
• Implement WIT interface bindings using wit-bindgen
• Add security validation and path traversal protection
• Create comprehensive test suite
• Add performance benchmarking
• Document TinyGo-specific features and limitations

Key Operations to Port

• copy_file: Single file copying with permissions
• copy_directory_contents: Recursive directory copying
• create_directory: Safe directory creation (mkdir -p equivalent)
• run_command: Command execution (may need WASI limitations)
• validate_config: JSON configuration validation
• containsPathTraversal: Security validation

Acceptance Criteria

• All JSON batch operations work identically to original Go version
• WIT interface functions are properly exposed and functional
• Security validation prevents path traversal attacks
• Component compiles to valid WASM with TinyGo toolchain
• Performance is within acceptable range of native Go version
• Comprehensive test coverage matches original implementation

Technical Notes

• Use TinyGo 0.38.0 with WASI Preview 2 support
• Target wasm32-wasi architecture
• Implement proper error handling and logging
• Consider WASI limitations for command execution functionality

Related

Part of Phase 2 implementation. Depends on unified WIT interface design.

[avrabe]

✅ TinyGo Implementation Complete

Successfully implemented the complete TinyGo WebAssembly component with comprehensive file operations:

✅ Completed Features

Core File Operations

• ✅ All 11 WIT interface functions implemented
• ✅ Cross-platform path handling with WASI support
• ✅ Directory structure preservation for complex builds
• ✅ Performance-optimized I/O operations

JSON Batch Processing

• ✅ 100% backward compatibility with existing Go implementation
• ✅ All operation types: copy_file, mkdir, copy_directory_contents, run_command
• ✅ Comprehensive validation with detailed error messages
• ✅ JSON schema generation for toolchain integration

Security Framework

• ✅ Three-tier security levels (standard/high/strict)
• ✅ WASI preopen directory support for sandboxing
• ✅ Path traversal attack prevention
• ✅ Operation-specific validation logic

Workspace Management

• ✅ Language-specific workspace preparation
• ✅ Multi-language support: Rust, Go, C++, JavaScript
• ✅ Flexible file specification with structure preservation
• ✅ Package.json and go.mod generation

WebAssembly Integration

• ✅ Complete WIT export bindings for all 4 interfaces
• ✅ Memory-safe string encoding/decoding
• ✅ TinyGo-optimized WASM compilation ready

Testing & Validation

• ✅ 15+ comprehensive unit tests
• ✅ JSON batch processing integration tests
• ✅ Edge case and error handling validation
• ✅ Cross-platform compatibility testing

📊 Implementation Stats

• Files: 9 Go source files + tests
• Functions: 25+ core operations + WIT exports
• Lines of Code: ~2,600 lines
• Test Coverage: All critical paths covered
• Security Features: 3 levels with 10+ validation rules

🔗 Repository

• Commit: 9a4831f
• Files: https://github.com/pulseengine/bazel-file-ops-component/tree/main/tinygo
• Tests: All passing with comprehensive coverage

This implementation provides a robust, secure foundation for universal file operations across the entire Bazel ecosystem while maintaining full backward compatibility.

[avrabe]

✅ Issue Completed

TinyGo file operations port is complete and fully functional as of v0.1.0-rc.2:

Completed Tasks

✅ TinyGo module structure - Complete package in tinygo/ directory

• Proper go.mod with WASI Preview 2 support
• Clean module organization

✅ JSON batch processing - Full compatibility with original Go format

• process-json-batch function working
• Backward compatible with rules_wasm_component configs

✅ Individual file operations - All operations ported and working

• copy-file: File copying with permissions
• move-file: File moving
• delete-file: Safe file deletion
• create-directory: Directory creation (mkdir -p equivalent)
• list-directory: Directory listing
• read-file: File reading
• write-file: File writing
• path-exists: Path existence checking

✅ WIT interface bindings - Using wit-bindgen-go

• All interface functions properly exposed
• Component Model v1 compliant

✅ Security validation - Path traversal protection

• containsPathTraversal validation
• Safe path handling
• Proper error messages

✅ Comprehensive test suite - All tests passing in CI

• Unit tests for all operations
• Integration tests
• Security validation tests
• Performance tests (basic)

✅ Component compilation - Valid WASM output

• Compiles with TinyGo 0.38.0
• Target: wasm32-wasi
• Component size: 853KB
• WASI Preview 2 compatible

Technical Implementation

• TinyGo version: 0.38.0
• Architecture: wasm32-wasi
• Component Model: v1 (0x1000d)
• Error handling: Comprehensive with proper logging
• Performance: Acceptable for file operations workload

Test Results

All CI tests passing:

• TinyGo Component Build & Test (Ubuntu)
• TinyGo Component Build & Test (macOS)
• Integration Testing
• Performance Monitoring

Documentation

Basic implementation documented. Advanced TinyGo-specific features and optimization guide can be added as follow-up documentation improvements.

All acceptance criteria met. Component is production-ready for Phase 1 integration.