working ipv6 ip assignment + ssh with login/passwd

- Update README.md to provide a clearer structure and improved
  installation instructions.  This makes it easier for users to
  understand and use the library.
- Remove outdated and unnecessary sections like the workspace
  structure details, publishing status, and detailed features
  lists. The information is either not relevant anymore or can be
  found elsewhere.
- Simplify installation instructions to focus on the core aspects
  of installing individual packages or the meta-package with
  features.
- Add a dedicated section for building and running tests,
  improving developer experience and making the process more
  transparent.
- Modernize the overall layout and formatting for better
  readability.

.github/workflows/publish.yml

@@ -0,0 +1,227 @@
+name: Publish SAL Crates
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to publish (e.g., 0.1.0)'
+        required: true
+        type: string
+      dry_run:
+        description: 'Dry run (do not actually publish)'
+        required: false
+        type: boolean
+        default: false
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  publish:
+    name: Publish to crates.io
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: stable
+    
+    - name: Cache Cargo dependencies
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.cargo/bin/
+          ~/.cargo/registry/index/
+          ~/.cargo/registry/cache/
+          ~/.cargo/git/db/
+          target/
+        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-cargo-
+    
+    - name: Install cargo-edit for version management
+      run: cargo install cargo-edit
+    
+    - name: Set version from release tag
+      if: github.event_name == 'release'
+      run: |
+        VERSION=${GITHUB_REF#refs/tags/v}
+        echo "PUBLISH_VERSION=$VERSION" >> $GITHUB_ENV
+        echo "Publishing version: $VERSION"
+    
+    - name: Set version from workflow input
+      if: github.event_name == 'workflow_dispatch'
+      run: |
+        echo "PUBLISH_VERSION=${{ github.event.inputs.version }}" >> $GITHUB_ENV
+        echo "Publishing version: ${{ github.event.inputs.version }}"
+    
+    - name: Update version in all crates
+      run: |
+        echo "Updating version to $PUBLISH_VERSION"
+        
+        # Update root Cargo.toml
+        cargo set-version $PUBLISH_VERSION
+        
+        # Update each crate
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai)
+        for crate in "${CRATES[@]}"; do
+          if [ -d "$crate" ]; then
+            cd "$crate"
+            cargo set-version $PUBLISH_VERSION
+            cd ..
+            echo "Updated $crate to version $PUBLISH_VERSION"
+          fi
+        done
+    
+    - name: Run tests
+      run: cargo test --workspace --verbose
+    
+    - name: Check formatting
+      run: cargo fmt --all -- --check
+    
+    - name: Run clippy
+      run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+    
+    - name: Dry run publish (check packages)
+      run: |
+        echo "Checking all packages can be published..."
+        
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai)
+        for crate in "${CRATES[@]}"; do
+          if [ -d "$crate" ]; then
+            echo "Checking $crate..."
+            cd "$crate"
+            cargo publish --dry-run
+            cd ..
+          fi
+        done
+        
+        echo "Checking main crate..."
+        cargo publish --dry-run
+    
+    - name: Publish crates (dry run)
+      if: github.event.inputs.dry_run == 'true'
+      run: |
+        echo "🔍 DRY RUN MODE - Would publish the following crates:"
+        echo "Individual crates: sal-os, sal-process, sal-text, sal-net, sal-git, sal-vault, sal-kubernetes, sal-virt, sal-redisclient, sal-postgresclient, sal-zinit-client, sal-mycelium, sal-rhai"
+        echo "Meta-crate: sal"
+        echo "Version: $PUBLISH_VERSION"
+    
+    - name: Publish individual crates
+      if: github.event.inputs.dry_run != 'true'
+      env:
+        CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+      run: |
+        echo "Publishing individual crates..."
+        
+        # Crates in dependency order
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai)
+        
+        for crate in "${CRATES[@]}"; do
+          if [ -d "$crate" ]; then
+            echo "Publishing sal-$crate..."
+            cd "$crate"
+            
+            # Retry logic for transient failures
+            for attempt in 1 2 3; do
+              if cargo publish --token $CARGO_REGISTRY_TOKEN; then
+                echo "✅ sal-$crate published successfully"
+                break
+              else
+                if [ $attempt -eq 3 ]; then
+                  echo "❌ Failed to publish sal-$crate after 3 attempts"
+                  exit 1
+                else
+                  echo "⚠️ Attempt $attempt failed, retrying in 30 seconds..."
+                  sleep 30
+                fi
+              fi
+            done
+            
+            cd ..
+            
+            # Wait for crates.io to process
+            if [ "$crate" != "rhai" ]; then
+              echo "⏳ Waiting 30 seconds for crates.io to process..."
+              sleep 30
+            fi
+          fi
+        done
+    
+    - name: Publish main crate
+      if: github.event.inputs.dry_run != 'true'
+      env:
+        CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+      run: |
+        echo "Publishing main sal crate..."
+        
+        # Wait a bit longer before publishing the meta-crate
+        echo "⏳ Waiting 60 seconds for all individual crates to be available..."
+        sleep 60
+        
+        # Retry logic for the main crate
+        for attempt in 1 2 3; do
+          if cargo publish --token $CARGO_REGISTRY_TOKEN; then
+            echo "✅ Main sal crate published successfully"
+            break
+          else
+            if [ $attempt -eq 3 ]; then
+              echo "❌ Failed to publish main sal crate after 3 attempts"
+              exit 1
+            else
+              echo "⚠️ Attempt $attempt failed, retrying in 60 seconds..."
+              sleep 60
+            fi
+          fi
+        done
+    
+    - name: Create summary
+      if: always()
+      run: |
+        echo "## 📦 SAL Publishing Summary" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "**Version:** $PUBLISH_VERSION" >> $GITHUB_STEP_SUMMARY
+        echo "**Trigger:** ${{ github.event_name }}" >> $GITHUB_STEP_SUMMARY
+        
+        if [ "${{ github.event.inputs.dry_run }}" == "true" ]; then
+          echo "**Mode:** Dry Run" >> $GITHUB_STEP_SUMMARY
+        else
+          echo "**Mode:** Live Publishing" >> $GITHUB_STEP_SUMMARY
+        fi
+        
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### Published Crates" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-os" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-process" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-text" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-net" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-git" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-vault" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-kubernetes" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-virt" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-redisclient" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-postgresclient" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-zinit-client" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-mycelium" >> $GITHUB_STEP_SUMMARY
+        echo "- sal-rhai" >> $GITHUB_STEP_SUMMARY
+        echo "- sal (meta-crate)" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### Usage" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo '```bash' >> $GITHUB_STEP_SUMMARY
+        echo "# Individual crates" >> $GITHUB_STEP_SUMMARY
+        echo "cargo add sal-os sal-process sal-text" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "# Meta-crate with features" >> $GITHUB_STEP_SUMMARY
+        echo "cargo add sal --features core" >> $GITHUB_STEP_SUMMARY
+        echo "cargo add sal --features all" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY

.github/workflows/test-publish.yml

@@ -0,0 +1,233 @@
+name: Test Publishing Setup
+
+on:
+  push:
+    branches: [ main, master ]
+    paths:
+      - '**/Cargo.toml'
+      - 'scripts/publish-all.sh'
+      - '.github/workflows/publish.yml'
+  pull_request:
+    branches: [ main, master ]
+    paths:
+      - '**/Cargo.toml'
+      - 'scripts/publish-all.sh'
+      - '.github/workflows/publish.yml'
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test-publish-setup:
+    name: Test Publishing Setup
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+    
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: stable
+    
+    - name: Cache Cargo dependencies
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.cargo/bin/
+          ~/.cargo/registry/index/
+          ~/.cargo/registry/cache/
+          ~/.cargo/git/db/
+          target/
+        key: ${{ runner.os }}-cargo-publish-test-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-cargo-publish-test-
+          ${{ runner.os }}-cargo-
+    
+    - name: Install cargo-edit
+      run: cargo install cargo-edit
+    
+    - name: Test workspace structure
+      run: |
+        echo "Testing workspace structure..."
+        
+        # Check that all expected crates exist
+        EXPECTED_CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai herodo)
+        
+        for crate in "${EXPECTED_CRATES[@]}"; do
+          if [ -d "$crate" ] && [ -f "$crate/Cargo.toml" ]; then
+            echo "✅ $crate exists"
+          else
+            echo "❌ $crate missing or invalid"
+            exit 1
+          fi
+        done
+    
+    - name: Test feature configuration
+      run: |
+        echo "Testing feature configuration..."
+        
+        # Test that features work correctly
+        cargo check --features os
+        cargo check --features process
+        cargo check --features text
+        cargo check --features net
+        cargo check --features git
+        cargo check --features vault
+        cargo check --features kubernetes
+        cargo check --features virt
+        cargo check --features redisclient
+        cargo check --features postgresclient
+        cargo check --features zinit_client
+        cargo check --features mycelium
+        cargo check --features rhai
+        
+        echo "✅ All individual features work"
+        
+        # Test feature groups
+        cargo check --features core
+        cargo check --features clients
+        cargo check --features infrastructure
+        cargo check --features scripting
+        
+        echo "✅ All feature groups work"
+        
+        # Test all features
+        cargo check --features all
+        
+        echo "✅ All features together work"
+    
+    - name: Test dry-run publishing
+      run: |
+        echo "Testing dry-run publishing..."
+        
+        # Test each individual crate can be packaged
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai)
+        
+        for crate in "${CRATES[@]}"; do
+          echo "Testing sal-$crate..."
+          cd "$crate"
+          cargo publish --dry-run
+          cd ..
+          echo "✅ sal-$crate can be published"
+        done
+        
+        # Test main crate
+        echo "Testing main sal crate..."
+        cargo publish --dry-run
+        echo "✅ Main sal crate can be published"
+    
+    - name: Test publishing script
+      run: |
+        echo "Testing publishing script..."
+        
+        # Make script executable
+        chmod +x scripts/publish-all.sh
+        
+        # Test dry run
+        ./scripts/publish-all.sh --dry-run --version 0.1.0-test
+        
+        echo "✅ Publishing script works"
+    
+    - name: Test version consistency
+      run: |
+        echo "Testing version consistency..."
+        
+        # Get version from root Cargo.toml
+        ROOT_VERSION=$(grep '^version = ' Cargo.toml | head -1 | sed 's/version = "\(.*\)"/\1/')
+        echo "Root version: $ROOT_VERSION"
+        
+        # Check all crates have the same version
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai herodo)
+        
+        for crate in "${CRATES[@]}"; do
+          if [ -f "$crate/Cargo.toml" ]; then
+            CRATE_VERSION=$(grep '^version = ' "$crate/Cargo.toml" | head -1 | sed 's/version = "\(.*\)"/\1/')
+            if [ "$CRATE_VERSION" = "$ROOT_VERSION" ]; then
+              echo "✅ $crate version matches: $CRATE_VERSION"
+            else
+              echo "❌ $crate version mismatch: $CRATE_VERSION (expected $ROOT_VERSION)"
+              exit 1
+            fi
+          fi
+        done
+    
+    - name: Test metadata completeness
+      run: |
+        echo "Testing metadata completeness..."
+        
+        # Check that all crates have required metadata
+        CRATES=(os process text net git vault kubernetes virt redisclient postgresclient zinit_client mycelium rhai)
+        
+        for crate in "${CRATES[@]}"; do
+          echo "Checking sal-$crate metadata..."
+          cd "$crate"
+          
+          # Check required fields exist
+          if ! grep -q '^name = "sal-' Cargo.toml; then
+            echo "❌ $crate missing or incorrect name"
+            exit 1
+          fi
+          
+          if ! grep -q '^description = ' Cargo.toml; then
+            echo "❌ $crate missing description"
+            exit 1
+          fi
+          
+          if ! grep -q '^repository = ' Cargo.toml; then
+            echo "❌ $crate missing repository"
+            exit 1
+          fi
+          
+          if ! grep -q '^license = ' Cargo.toml; then
+            echo "❌ $crate missing license"
+            exit 1
+          fi
+          
+          echo "✅ sal-$crate metadata complete"
+          cd ..
+        done
+    
+    - name: Test dependency resolution
+      run: |
+        echo "Testing dependency resolution..."
+        
+        # Test that all workspace dependencies resolve correctly
+        cargo tree --workspace > /dev/null
+        echo "✅ All dependencies resolve correctly"
+        
+        # Test that there are no dependency conflicts
+        cargo check --workspace
+        echo "✅ No dependency conflicts"
+    
+    - name: Generate publishing report
+      if: always()
+      run: |
+        echo "## 🧪 Publishing Setup Test Report" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### ✅ Tests Passed" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "- Workspace structure validation" >> $GITHUB_STEP_SUMMARY
+        echo "- Feature configuration testing" >> $GITHUB_STEP_SUMMARY
+        echo "- Dry-run publishing simulation" >> $GITHUB_STEP_SUMMARY
+        echo "- Publishing script validation" >> $GITHUB_STEP_SUMMARY
+        echo "- Version consistency check" >> $GITHUB_STEP_SUMMARY
+        echo "- Metadata completeness verification" >> $GITHUB_STEP_SUMMARY
+        echo "- Dependency resolution testing" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### 📦 Ready for Publishing" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "All SAL crates are ready for publishing to crates.io!" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "**Individual Crates:** 13 modules" >> $GITHUB_STEP_SUMMARY
+        echo "**Meta-crate:** sal with optional features" >> $GITHUB_STEP_SUMMARY
+        echo "**Binary:** herodo script executor" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### 🚀 Next Steps" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "1. Create a release tag (e.g., v0.1.0)" >> $GITHUB_STEP_SUMMARY
+        echo "2. The publish workflow will automatically trigger" >> $GITHUB_STEP_SUMMARY
+        echo "3. All crates will be published to crates.io" >> $GITHUB_STEP_SUMMARY
+        echo "4. Users can install with: \`cargo add sal-os\` or \`cargo add sal --features all\`" >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -62,3 +62,5 @@ docusaurus.config.ts
 sidebars.ts
 
 tsconfig.json
+Cargo.toml.bak
+for_augment

.roo/mcp.json

@@ -1,16 +0,0 @@
-{
-  "mcpServers": {
-    "gitea": {
-      "command": "/Users/despiegk/hero/bin/mcpgitea",
-      "args": [
-        "-t", "stdio",
-        "--host", "https://gitea.com",
-        "--token", "5bd13c898368a2edbfcef43f898a34857b51b37a"
-      ],
-      "env": {
-        "GITEA_HOST": "https://git.ourworld.tf/",
-        "GITEA_ACCESS_TOKEN": "5bd13c898368a2edbfcef43f898a34857b51b37a"
-      }
-    }
-  }
-}

Cargo.toml

@@ -4,65 +4,196 @@ version = "0.1.0"
 edition = "2021"
 authors = ["PlanetFirst <info@incubaid.com>"]
 description = "System Abstraction Layer - A library for easy interaction with operating system features"
-repository = "https://git.ourworld.tf/herocode/sal"
+repository = "https://git.threefold.info/herocode/sal"
 license = "Apache-2.0"
 keywords = ["system", "os", "abstraction", "platform", "filesystem"]
 categories = ["os", "filesystem", "api-bindings"]
 readme = "README.md"
 
-[dependencies]
+[workspace]
-anyhow = "1.0.98"
+members = [
-base64 = "0.22.1"  # Base64 encoding/decoding
+    "packages/clients/myceliumclient",
-cfg-if = "1.0"
+    "packages/clients/postgresclient",
-chacha20poly1305 = "0.10.1" # ChaCha20Poly1305 AEAD cipher
+    "packages/clients/redisclient",
-clap = "2.34.0" # Command-line argument parsing
+    "packages/clients/zinitclient",
-dirs = "6.0.0"     # Directory paths
+    "packages/core/net",
-env_logger = "0.11.8" # Logger implementation
+    "packages/core/text",
-ethers = { version = "2.0.7", features = ["legacy"] } # Ethereum library
+    "packages/crypt/vault",
-glob = "0.3.1" # For file pattern matching
+    "packages/data/ourdb",
-jsonrpsee = "0.25.1"
+    "packages/data/radixtree",
-k256 = { version = "0.13.4", features = ["ecdsa", "ecdh"] } # Elliptic curve cryptography
+    "packages/data/tst",
-lazy_static = "1.4.0" # For lazy initialization of static variables
+    "packages/system/git",
-libc = "0.2"
+    "packages/system/kubernetes",
-log = "0.4" # Logging facade
+    "packages/system/os",
-once_cell = "1.18.0" # Lazy static initialization
+    "packages/system/process",
-postgres = "0.19.4" # PostgreSQL client
+    "packages/system/virt",
-postgres-types = "0.2.5" # PostgreSQL type conversions
+    "rhai",
-r2d2 = "0.8.10"
+    "rhailib",
-r2d2_postgres = "0.18.2"
+    "herodo",
-rand = "0.8.5" # Random number generation
+    "packages/clients/hetznerclient",
-redis = "0.31.0" # Redis client
+]
-regex = "1.8.1" # For regex pattern matching
+resolver = "2"
-rhai = { version = "1.12.0", features = ["sync"] } # Embedded scripting language
-serde = { version = "1.0", features = [
-    "derive",
-] } # For serialization/deserialization
-serde_json = "1.0" # For JSON handling
-sha2 = "0.10.7"    # SHA-2 hash functions
-tempfile = "3.5" # For temporary file operations
-tera = "1.19.0" # Template engine for text rendering
-thiserror = "2.0.12" # For error handling
-tokio = "1.45.0"
-tokio-postgres = "0.7.8" # Async PostgreSQL client
-tokio-test = "0.4.4"
-uuid = { version = "1.16.0", features = ["v4"] }
-zinit-client = { git = "https://github.com/threefoldtech/zinit", branch = "json_rpc",  package = "zinit-client" }
-# Optional features for specific OS functionality
-[target.'cfg(unix)'.dependencies]
-nix = "0.30.1" # Unix-specific functionality
 
-[target.'cfg(windows)'.dependencies]
+[workspace.metadata]
+# Workspace-level metadata
+rust-version = "1.70.0"
+
+[workspace.dependencies]
+# Core shared dependencies with consistent versions
+anyhow = "1.0.98"
+base64 = "0.22.1"
+dirs = "6.0.0"
+env_logger = "0.11.8"
+futures = "0.3.30"
+glob = "0.3.1"
+lazy_static = "1.4.0"
+libc = "0.2"
+log = "0.4"
+once_cell = "1.18.0"
+rand = "0.8.5"
+regex = "1.8.1"
+reqwest = { version = "0.12.15", features = ["json", "blocking"] }
+rhai = { version = "1.12.0", features = ["sync"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tempfile = "3.5"
+thiserror = "2.0.12"
+tokio = { version = "1.45.0", features = ["full"] }
+url = "2.4"
+uuid = { version = "1.16.0", features = ["v4"] }
+
+# Database dependencies
+postgres = "0.19.10"
+r2d2_postgres = "0.18.2"
+redis = "0.31.0"
+tokio-postgres = "0.7.13"
+
+# Crypto dependencies
+chacha20poly1305 = "0.10.1"
+k256 = { version = "0.13.4", features = ["ecdsa", "ecdh"] }
+sha2 = "0.10.7"
+hex = "0.4"
+bincode = { version = "2.0.1", features = ["serde"] }
+pbkdf2 = "0.12.2"
+getrandom = { version = "0.3.3", features = ["wasm_js"] }
+tera = "1.19.0"
+
+# Ethereum dependencies
+ethers = { version = "2.0.7", features = ["legacy"] }
+
+# Platform-specific dependencies
+nix = "0.30.1"
 windows = { version = "0.61.1", features = [
     "Win32_Foundation",
     "Win32_System_Threading",
     "Win32_Storage_FileSystem",
 ] }
 
-[dev-dependencies]
+# Specialized dependencies
-mockall = "0.13.1" # For mocking in tests
+zinit-client = "0.4.0"
-tempfile = "3.5"   # For tests that need temporary files/directories
+urlencoding = "2.1.3"
-tokio = { version = "1.28", features = ["full", "test-util"] } # For async testing
+tokio-test = "0.4.4"
+kube = { version = "0.95.0", features = ["client", "config", "derive"] }
+k8s-openapi = { version = "0.23.0", features = ["latest"] }
+tokio-retry = "0.3.0"
+governor = "0.6.3"
+tower = { version = "0.5.2", features = ["timeout", "limit"] }
+serde_yaml = "0.9"
+postgres-types = "0.2.5"
+r2d2 = "0.8.10"
 
-[[bin]]
+# SAL dependencies
-name = "herodo"
+sal-git = { path = "packages/system/git" }
-path = "src/bin/herodo.rs"
+sal-kubernetes = { path = "packages/system/kubernetes" }
+sal-redisclient = { path = "packages/clients/redisclient" }
+sal-mycelium = { path = "packages/clients/myceliumclient" }
+sal-hetzner = { path = "packages/clients/hetznerclient" }
+sal-text = { path = "packages/core/text" }
+sal-os = { path = "packages/system/os" }
+sal-net = { path = "packages/core/net" }
+sal-zinit-client = { path = "packages/clients/zinitclient" }
+sal-process = { path = "packages/system/process" }
+sal-virt = { path = "packages/system/virt" }
+sal-postgresclient = { path = "packages/clients/postgresclient" }
+sal-vault = { path = "packages/crypt/vault" }
+sal-rhai = { path = "rhai" }
+sal-service-manager = { path = "_archive/service_manager" }
+
+[dependencies]
+thiserror = { workspace = true }
+tokio = { workspace = true }
+
+# Optional dependencies - users can choose which modules to include
+sal-git = { workspace = true, optional = true }
+sal-kubernetes = { workspace = true, optional = true }
+sal-redisclient = { workspace = true, optional = true }
+sal-mycelium = { workspace = true, optional = true }
+sal-hetzner = { workspace = true, optional = true }
+sal-text = { workspace = true, optional = true }
+sal-os = { workspace = true, optional = true }
+sal-net = { workspace = true, optional = true }
+sal-zinit-client = { workspace = true, optional = true }
+sal-process = { workspace = true, optional = true }
+sal-virt = { workspace = true, optional = true }
+sal-postgresclient = { workspace = true, optional = true }
+sal-vault = { workspace = true, optional = true }
+sal-rhai = { workspace = true, optional = true }
+sal-service-manager = { workspace = true, optional = true }
+
+[features]
+default = []
+
+# Individual module features
+git = ["dep:sal-git"]
+kubernetes = ["dep:sal-kubernetes"]
+redisclient = ["dep:sal-redisclient"]
+mycelium = ["dep:sal-mycelium"]
+hetzner = ["dep:sal-hetzner"]
+text = ["dep:sal-text"]
+os = ["dep:sal-os"]
+net = ["dep:sal-net"]
+zinit_client = ["dep:sal-zinit-client"]
+process = ["dep:sal-process"]
+virt = ["dep:sal-virt"]
+postgresclient = ["dep:sal-postgresclient"]
+vault = ["dep:sal-vault"]
+rhai = ["dep:sal-rhai"]
+# service_manager is removed as it's not a direct member anymore
+
+# Convenience feature groups
+core = ["os", "process", "text", "net"]
+clients = ["redisclient", "postgresclient", "zinit_client", "mycelium", "hetzner"]
+infrastructure = ["git", "vault", "kubernetes", "virt"]
+scripting = ["rhai"]
+all = [
+    "git",
+    "kubernetes",
+    "redisclient",
+    "mycelium",
+    "hetzner",
+    "text",
+    "os",
+    "net",
+    "zinit_client",
+    "process",
+    "virt",
+    "postgresclient",
+    "vault",
+    "rhai",
+]
+
+# Examples
+[[example]]
+name = "postgres_cluster"
+path = "examples/kubernetes/clusters/postgres.rs"
+required-features = ["kubernetes"]
+
+[[example]]
+name = "redis_cluster"
+path = "examples/kubernetes/clusters/redis.rs"
+required-features = ["kubernetes"]
+
+[[example]]
+name = "generic_cluster"
+path = "examples/kubernetes/clusters/generic.rs"
+required-features = ["kubernetes"]

PUBLISHING.md

@@ -0,0 +1,239 @@
+# SAL Publishing Guide
+
+This guide explains how to publish SAL crates to crates.io and how users can consume them.
+
+## 🎯 Publishing Strategy
+
+SAL uses a **modular publishing approach** where each module is published as an individual crate. This allows users to install only the functionality they need, reducing compilation time and binary size.
+
+## 📦 Crate Structure
+
+### Individual Crates
+
+Each SAL module is published as a separate crate:
+
+| Crate Name | Description | Category |
+|------------|-------------|----------|
+| `sal-os` | Operating system operations | Core |
+| `sal-process` | Process management | Core |
+| `sal-text` | Text processing utilities | Core |
+| `sal-net` | Network operations | Core |
+| `sal-git` | Git repository management | Infrastructure |
+| `sal-vault` | Cryptographic operations | Infrastructure |
+| `sal-kubernetes` | Kubernetes cluster management | Infrastructure |
+| `sal-virt` | Virtualization tools (Buildah, nerdctl) | Infrastructure |
+| `sal-redisclient` | Redis database client | Clients |
+| `sal-postgresclient` | PostgreSQL database client | Clients |
+| `sal-zinit-client` | Zinit process supervisor client | Clients |
+| `sal-mycelium` | Mycelium network client | Clients |
+| `sal-rhai` | Rhai scripting integration | Scripting |
+
+### Meta-crate
+
+The main `sal` crate serves as a meta-crate that re-exports all modules with optional features:
+
+```toml
+[dependencies]
+sal = { version = "0.1.0", features = ["os", "process", "text"] }
+```
+
+## 🚀 Publishing Process
+
+### Prerequisites
+
+1. **Crates.io Account**: Ensure you have a crates.io account and API token
+2. **Repository Access**: Ensure the repository URL is accessible
+3. **Version Consistency**: All crates should use the same version number
+
+### Publishing Individual Crates
+
+Each crate can be published independently:
+
+```bash
+# Publish core modules
+cd os && cargo publish
+cd ../process && cargo publish
+cd ../text && cargo publish
+cd ../net && cargo publish
+
+# Publish infrastructure modules
+cd ../git && cargo publish
+cd ../vault && cargo publish
+cd ../kubernetes && cargo publish
+cd ../virt && cargo publish
+
+# Publish client modules
+cd ../redisclient && cargo publish
+cd ../postgresclient && cargo publish
+cd ../zinit_client && cargo publish
+cd ../mycelium && cargo publish
+
+# Publish scripting module
+cd ../rhai && cargo publish
+
+# Finally, publish the meta-crate
+cd .. && cargo publish
+```
+
+### Automated Publishing
+
+Use the comprehensive publishing script:
+
+```bash
+# Test the publishing process (safe)
+./scripts/publish-all.sh --dry-run --version 0.1.0
+
+# Actually publish to crates.io
+./scripts/publish-all.sh --version 0.1.0
+```
+
+The script handles:
+- ✅ **Dependency order** - Publishes crates in correct dependency order
+- ✅ **Path dependencies** - Automatically updates path deps to version deps
+- ✅ **Rate limiting** - Waits between publishes to avoid rate limits
+- ✅ **Error handling** - Stops on failures with clear error messages
+- ✅ **Dry run mode** - Test without actually publishing
+
+## 👥 User Consumption
+
+### Installation Options
+
+#### Option 1: Individual Crates (Recommended)
+
+Users install only what they need:
+
+```bash
+# Core functionality
+cargo add sal-os sal-process sal-text sal-net
+
+# Database operations
+cargo add sal-redisclient sal-postgresclient
+
+# Infrastructure management
+cargo add sal-git sal-vault sal-kubernetes
+
+# Service integration
+cargo add sal-zinit-client sal-mycelium
+
+# Scripting
+cargo add sal-rhai
+```
+
+**Usage:**
+```rust
+use sal_os::fs;
+use sal_process::run;
+use sal_git::GitManager;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let files = fs::list_files(".")?;
+    let result = run::command("echo hello")?;
+    let git = GitManager::new(".")?;
+    Ok(())
+}
+```
+
+#### Option 2: Meta-crate with Features
+
+Users can use the main crate with selective features:
+
+```bash
+# Specific modules
+cargo add sal --features os,process,text
+
+# Feature groups
+cargo add sal --features core              # os, process, text, net
+cargo add sal --features clients           # redisclient, postgresclient, zinit_client, mycelium
+cargo add sal --features infrastructure    # git, vault, kubernetes, virt
+cargo add sal --features scripting         # rhai
+
+# Everything
+cargo add sal --features all
+```
+
+**Usage:**
+```rust
+// Cargo.toml: sal = { version = "0.1.0", features = ["os", "process", "git"] }
+use sal::os::fs;
+use sal::process::run;
+use sal::git::GitManager;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let files = fs::list_files(".")?;
+    let result = run::command("echo hello")?;
+    let git = GitManager::new(".")?;
+    Ok(())
+}
+```
+
+### Feature Groups
+
+The meta-crate provides convenient feature groups:
+
+- **`core`**: Essential system operations (os, process, text, net)
+- **`clients`**: Database and service clients (redisclient, postgresclient, zinit_client, mycelium)
+- **`infrastructure`**: Infrastructure management tools (git, vault, kubernetes, virt)
+- **`scripting`**: Rhai scripting support (rhai)
+- **`all`**: Everything included
+
+## 📋 Version Management
+
+### Semantic Versioning
+
+All SAL crates follow semantic versioning:
+
+- **Major version**: Breaking API changes
+- **Minor version**: New features, backward compatible
+- **Patch version**: Bug fixes, backward compatible
+
+### Synchronized Releases
+
+All crates are released with the same version number to ensure compatibility:
+
+```toml
+# All crates use the same version
+sal-os = "0.1.0"
+sal-process = "0.1.0"
+sal-git = "0.1.0"
+# etc.
+```
+
+## 🔧 Maintenance
+
+### Updating Dependencies
+
+When updating dependencies:
+
+1. Update `Cargo.toml` in the workspace root
+2. Update individual crate dependencies if needed
+3. Test all crates: `cargo test --workspace`
+4. Publish with incremented version numbers
+
+### Adding New Modules
+
+To add a new SAL module:
+
+1. Create the new crate directory
+2. Add to workspace members in root `Cargo.toml`
+3. Add optional dependency in root `Cargo.toml`
+4. Add feature flag in root `Cargo.toml`
+5. Add conditional re-export in `src/lib.rs`
+6. Update documentation
+
+## 🎉 Benefits
+
+### For Users
+
+- **Minimal Dependencies**: Install only what you need
+- **Faster Builds**: Smaller dependency trees compile faster
+- **Smaller Binaries**: Reduced binary size
+- **Clear Dependencies**: Explicit about what functionality is used
+
+### For Maintainers
+
+- **Independent Releases**: Can release individual crates as needed
+- **Focused Testing**: Test individual modules in isolation
+- **Clear Ownership**: Each crate has clear responsibility
+- **Easier Maintenance**: Smaller, focused codebases
+
+This publishing strategy provides the best of both worlds: modularity for users who want minimal dependencies, and convenience for users who prefer a single crate with features.

README.md

@@ -1,73 +1,136 @@
-# SAL (System Abstraction Layer)
+# Herocode Herolib Rust Repository
 
-A Rust library that provides a unified interface for interacting with operating system features across different platforms. It abstracts away platform-specific details, allowing developers to write cross-platform code with ease.
+## Overview
 
-## Features
+This repository contains the **Herocode Herolib** Rust library and a collection of scripts, examples, and utilities for building, testing, and publishing the SAL (System Abstraction Layer) crates. The repository includes:
 
-- **File System Operations**: Simplified file and directory management
+- **Rust crates** for various system components (e.g., `os`, `process`, `text`, `git`, `vault`, `kubernetes`, etc.).
-- **Process Management**: Create, monitor, and control processes
+- **Rhai scripts** and test suites for each crate.
-- **System Information**: Access system details and metrics
+- **Utility scripts** to automate common development tasks.
-- **Git Integration**: Interface with Git repositories
-- **Redis Client**: Robust Redis connection management and command execution
-- **Text Processing**: Utilities for text manipulation and formatting
 
-## Modules
+## Scripts
 
-### Redis Client
+The repository provides three primary helper scripts located in the repository root:
 
-The Redis client module provides a robust wrapper around the Redis client library for Rust, offering:
+| Script | Description | Typical Usage |
+|--------|-------------|--------------|
+| `scripts/publish-all.sh` | Publishes all SAL crates to **crates.io** in the correct dependency order. Handles version bumping, dependency updates, dry‑run mode, and rate‑limiting. | `./scripts/publish-all.sh [--dry-run] [--wait <seconds>] [--version <ver>]` |
+| `build_herodo.sh` | Builds the `herodo` binary from the `herodo` package and optionally runs a specified Rhai script. | `./build_herodo.sh [script_name]` |
+| `run_rhai_tests.sh` | Executes all Rhai test suites across the repository, logging results and providing a summary. | `./run_rhai_tests.sh` |
 
-- Automatic connection management and reconnection
+Below are detailed usage instructions for each script.
-- Support for both Unix socket and TCP connections
-- Database selection via environment variables
-- Thread-safe global client instance
-- Simple command execution interface
 
-[View Redis Client Documentation](src/redisclient/README.md)
+---
 
-### OS Module
+## 1. `scripts/publish-all.sh`
 
-Provides platform-independent interfaces for operating system functionality.
+### Purpose
 
-### Git Module
+- Publishes each SAL crate in the correct dependency order.
+- Updates crate versions (if `--version` is supplied).
+- Updates path dependencies to version dependencies before publishing.
+- Supports **dry‑run** mode to preview actions without publishing.
+- Handles rate‑limiting between crate publishes.
 
-Tools for interacting with Git repositories programmatically.
+### Options
 
-### Process Module
+| Option | Description |
+|--------|-------------|
+| `--dry-run` | Shows what would be published without actually publishing. |
+| `--wait <seconds>` | Wait time between publishes (default: 15 s). |
+| `--version <ver>` | Set a new version for all crates (updates `Cargo.toml` files). |
+| `-h, --help` | Show help message. |
 
-Utilities for process creation, monitoring, and management.
+### Example Usage
 
-### Text Module
+```bash
+# Dry run – no crates will be published
+./scripts/publish-all.sh --dry-run
 
-Text processing utilities for common operations.
+# Publish with a custom wait time and version bump
+./scripts/publish-all.sh --wait 30 --version 1.2.3
 
-## Usage
+# Normal publish (no dry‑run)
-
+./scripts/publish-all.sh
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-sal = "0.1.0"
 ```
 
-Basic example:
+### Notes
 
-```rust
+- Must be run from the repository root (where `Cargo.toml` lives).
-use sal::redisclient::execute;
+- Requires `cargo` and a logged‑in `cargo` session (`cargo login`).
-use redis::cmd;
+- The script automatically updates dependencies in each crate’s `Cargo.toml` to use the new version before publishing.
 
-fn main() -> redis::RedisResult<()> {
+---
-    // Execute a Redis command
-    let mut cmd = redis::cmd("SET");
-    cmd.arg("example_key").arg("example_value");
-    execute(&mut cmd)?;
 
-    // Retrieve the value
+## 2. `build_herodo.sh`
-    let mut get_cmd = redis::cmd("GET");
-    get_cmd.arg("example_key");
-    let value: String = execute(&mut get_cmd)?;
-    println!("Value: {}", value);
 
-    Ok(())
+### Purpose
-}
+
+- Builds the `herodo` binary from the `herodo` package.
+- Copies the binary to a system‑wide location (`/usr/local/bin`) if run as root, otherwise to `~/hero/bin`.
+- Optionally runs a specified Rhai script after building.
+
+### Usage
+
+```bash
+# Build only
+./build_herodo.sh
+
+# Build and run a specific Rhai script (e.g., `example`):
+./build_herodo.sh example
 ```
+
+### Details
+
+- The script changes to its own directory, builds the `herodo` crate (`cargo build`), and copies the binary.
+- If a script name is provided, it looks for the script in:
+  - `src/rhaiexamples/<name>.rhai`
+  - `src/herodo/scripts/<name>.rhai`
+- If the script is not found, the script exits with an error.
+
+---
+
+## 3. `run_rhai_tests.sh`
+
+### Purpose
+
+- Runs **all** Rhai test suites across the repository.
+- Supports both the legacy `rhai_tests` directory and the newer `*/tests/rhai` layout.
+- Logs output to `run_rhai_tests.log` and prints a summary.
+
+### Usage
+
+```bash
+# Run all tests
+./run_rhai_tests.sh
+```
+
+### Output
+
+- Colored console output for readability.
+- Log file (`run_rhai_tests.log`) contains full output for later review.
+- Summary includes total modules, passed, and failed counts.
+- Exit code `0` if all tests pass, `1` otherwise.
+
+---
+
+## General Development Workflow
+
+1. **Build**: Use `build_herodo.sh` to compile the `herodo` binary.
+2. **Test**: Run `run_rhai_tests.sh` to ensure all Rhai scripts pass.
+3. **Publish**: When ready to release, use `scripts/publish-all.sh` (with `--dry-run` first to verify).
+
+## Prerequisites
+
+- **Rust toolchain** (`cargo`, `rustc`) installed.
+- **Rhai** interpreter (`herodo`) built and available.
+- **Git** for version control.
+- **Cargo login** for publishing to crates.io.
+
+## License
+
+See `LICENSE` for details.
+
+---
+
+**Happy coding!**

_archive/service_manager/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "sal-service-manager"
+version = "0.1.0"
+edition = "2021"
+authors = ["PlanetFirst <info@incubaid.com>"]
+description = "SAL Service Manager - Cross-platform service management for dynamic worker deployment"
+repository = "https://git.threefold.info/herocode/sal"
+license = "Apache-2.0"
+
+[dependencies]
+# Use workspace dependencies for consistency
+thiserror = "1.0"
+tokio = { workspace = true }
+log = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+futures = { workspace = true }
+once_cell = { workspace = true }
+# Use base zinit-client instead of SAL wrapper
+zinit-client = { version = "0.4.0" }
+# Optional Rhai integration
+rhai = { workspace = true, optional = true }
+
+
+[target.'cfg(target_os = "macos")'.dependencies]
+# macOS-specific dependencies for launchctl
+plist = "1.6"
+
+[features]
+default = ["zinit"]
+zinit = []
+rhai = ["dep:rhai"]
+
+# Enable zinit feature for tests
+[dev-dependencies]
+tokio-test = "0.4"
+rhai = { workspace = true }
+tempfile = { workspace = true }
+env_logger = "0.10"
+
+[[test]]
+name = "zinit_integration_tests"
+required-features = ["zinit"]

_archive/service_manager/README.md

@@ -0,0 +1,198 @@
+# SAL Service Manager
+
+[![Crates.io](https://img.shields.io/crates/v/sal-service-manager.svg)](https://crates.io/crates/sal-service-manager)
+[![Documentation](https://docs.rs/sal-service-manager/badge.svg)](https://docs.rs/sal-service-manager)
+
+A cross-platform service management library for the System Abstraction Layer (SAL). This crate provides a unified interface for managing system services across different platforms, enabling dynamic deployment of workers and services.
+
+## Features
+
+- **Cross-platform service management** - Unified API across macOS and Linux
+- **Dynamic worker deployment** - Perfect for circle workers and on-demand services
+- **Platform-specific implementations**:
+  - **macOS**: Uses `launchctl` with plist management
+  - **Linux**: Uses `zinit` for lightweight service management (systemd also available)
+- **Complete lifecycle management** - Start, stop, restart, status monitoring, and log retrieval
+- **Service configuration** - Environment variables, working directories, auto-restart
+- **Production-ready** - Comprehensive error handling and resource management
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+sal-service-manager = "0.1.0"
+```
+
+Or use it as part of the SAL ecosystem:
+
+```toml
+[dependencies]
+sal = { version = "0.1.0", features = ["service_manager"] }
+```
+
+## Primary Use Case: Dynamic Circle Worker Management
+
+This service manager was designed specifically for dynamic deployment of circle workers in freezone environments. When a new resident registers, you can instantly launch a dedicated circle worker:
+
+```rust,no_run
+use sal_service_manager::{create_service_manager, ServiceConfig};
+use std::collections::HashMap;
+
+// New resident registration triggers worker creation
+fn deploy_circle_worker(resident_id: &str) -> Result<(), Box<dyn std::error::Error>> {
+    let manager = create_service_manager();
+
+    let mut env = HashMap::new();
+    env.insert("RESIDENT_ID".to_string(), resident_id.to_string());
+    env.insert("WORKER_TYPE".to_string(), "circle".to_string());
+
+    let config = ServiceConfig {
+        name: format!("circle-worker-{}", resident_id),
+        binary_path: "/usr/bin/circle-worker".to_string(),
+        args: vec!["--resident".to_string(), resident_id.to_string()],
+        working_directory: Some("/var/lib/circle-workers".to_string()),
+        environment: env,
+        auto_restart: true,
+    };
+
+    // Deploy the worker
+    manager.start(&config)?;
+    println!("✅ Circle worker deployed for resident: {}", resident_id);
+
+    Ok(())
+}
+```
+
+## Basic Usage Example
+
+Here is an example of the core service management API:
+
+```rust,no_run
+use sal_service_manager::{create_service_manager, ServiceConfig};
+use std::collections::HashMap;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let service_manager = create_service_manager();
+
+    let config = ServiceConfig {
+        name: "my-service".to_string(),
+        binary_path: "/usr/local/bin/my-service-executable".to_string(),
+        args: vec!["--config".to_string(), "/etc/my-service.conf".to_string()],
+        working_directory: Some("/var/tmp".to_string()),
+        environment: HashMap::new(),
+        auto_restart: true,
+    };
+
+    // Start a new service
+    service_manager.start(&config)?;
+
+    // Get the status of the service
+    let status = service_manager.status("my-service")?;
+    println!("Service status: {:?}", status);
+
+    // Stop the service
+    service_manager.stop("my-service")?;
+
+    Ok(())
+}
+```
+
+## Examples
+
+Comprehensive examples are available in the SAL examples directory:
+
+### Circle Worker Manager Example
+
+The primary use case - dynamically launching circle workers for new freezone residents:
+
+```bash
+# Run the circle worker management example
+herodo examples/service_manager/circle_worker_manager.rhai
+```
+
+This example demonstrates:
+- Creating service configurations for circle workers
+- Complete service lifecycle management
+- Error handling and status monitoring
+- Service cleanup and removal
+
+### Basic Usage Example
+
+A simpler example showing the core API:
+
+```bash
+# Run the basic usage example
+herodo examples/service_manager/basic_usage.rhai
+```
+
+See `examples/service_manager/README.md` for detailed documentation.
+
+## Testing
+
+Run the test suite:
+
+```bash
+cargo test -p sal-service-manager
+```
+
+For Rhai integration tests:
+
+```bash
+cargo test -p sal-service-manager --features rhai
+```
+
+### Testing with Herodo
+
+To test the service manager with real Rhai scripts using herodo, first build herodo:
+
+```bash
+./build_herodo.sh
+```
+
+Then run Rhai scripts that use the service manager:
+
+```bash
+herodo your_service_script.rhai
+```
+
+## Prerequisites
+
+### Linux (zinit/systemd)
+
+The service manager automatically discovers running zinit servers and falls back to systemd if none are found.
+
+**For zinit (recommended):**
+
+```bash
+# Start zinit with default socket
+zinit -s /tmp/zinit.sock init
+
+# Or with a custom socket path
+zinit -s /var/run/zinit.sock init
+```
+
+**Socket Discovery:**
+The service manager will automatically find running zinit servers by checking:
+1. `ZINIT_SOCKET_PATH` environment variable (if set)
+2. Common socket locations: `/var/run/zinit.sock`, `/tmp/zinit.sock`, `/run/zinit.sock`, `./zinit.sock`
+
+**Custom socket path:**
+```bash
+# Set custom socket path
+export ZINIT_SOCKET_PATH=/your/custom/path/zinit.sock
+```
+
+**Systemd fallback:**
+If no zinit server is detected, the service manager automatically falls back to systemd.
+
+### macOS (launchctl)
+
+No additional setup required - uses the built-in launchctl system.
+
+## Platform Support
+
+- **macOS**: Full support using `launchctl` for service management
+- **Linux**: Full support using `zinit` for service management (systemd also available as alternative)
+- **Windows**: Not currently supported

_archive/service_manager/examples/README.md

@@ -0,0 +1,47 @@
+# Service Manager Examples
+
+This directory contains examples demonstrating the usage of the `sal-service-manager` crate.
+
+## Running Examples
+
+To run any example, use the following command structure from the `service_manager` crate's root directory:
+
+```sh
+cargo run --example <EXAMPLE_NAME>
+```
+
+---
+
+### 1. `simple_service`
+
+This example demonstrates the ideal, clean lifecycle of a service using the separated `create` and `start` steps.
+
+**Behavior:**
+1.  Creates a new service definition.
+2.  Starts the newly created service.
+3.  Checks its status to confirm it's running.
+4.  Stops the service.
+5.  Checks its status again to confirm it's stopped.
+6.  Removes the service definition.
+
+**Run it:**
+```sh
+cargo run --example simple_service
+```
+
+### 2. `service_spaghetti`
+
+This example demonstrates how the service manager handles "messy" or improper sequences of operations, showcasing its error handling and robustness.
+
+**Behavior:**
+1.  Creates a service.
+2.  Starts the service.
+3.  Tries to start the **same service again** (which should fail as it's already running).
+4.  Removes the service **without stopping it first** (the manager should handle this gracefully).
+5.  Tries to stop the **already removed** service (which should fail).
+6.  Tries to remove the service **again** (which should also fail).
+
+**Run it:**
+```sh
+cargo run --example service_spaghetti
+```

_archive/service_manager/examples/service_spaghetti.rs

@@ -0,0 +1,109 @@
+//! service_spaghetti - An example of messy service management.
+//!
+//! This example demonstrates how the service manager behaves when commands
+//! are issued in a less-than-ideal order, such as starting a service that's
+//! already running or removing a service that hasn't been stopped.
+
+use sal_service_manager::{create_service_manager, ServiceConfig};
+use std::collections::HashMap;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    // Initialize logging to see socket discovery in action
+    env_logger::init();
+
+    let manager = match create_service_manager() {
+        Ok(manager) => manager,
+        Err(e) => {
+            eprintln!("Error: Failed to create service manager: {}", e);
+            return;
+        }
+    };
+    let service_name = "com.herocode.examples.spaghetti";
+
+    let service_config = ServiceConfig {
+        name: service_name.to_string(),
+        binary_path: "/bin/sh".to_string(),
+        args: vec![
+            "-c".to_string(),
+            "while true; do echo 'Spaghetti service is running...'; sleep 5; done".to_string(),
+        ],
+        working_directory: None,
+        environment: HashMap::new(),
+        auto_restart: false,
+    };
+
+    println!("--- Service Spaghetti Example ---");
+    println!("This example demonstrates messy, error-prone service management.");
+
+    // Cleanup from previous runs to ensure a clean slate
+    if let Ok(true) = manager.exists(service_name) {
+        println!(
+            "\nService '{}' found from a previous run. Cleaning up first.",
+            service_name
+        );
+        let _ = manager.stop(service_name);
+        let _ = manager.remove(service_name);
+        println!("Cleanup complete.");
+    }
+
+    // 1. Start the service (creates and starts in one step)
+    println!("\n1. Starting the service for the first time...");
+    match manager.start(&service_config) {
+        Ok(()) => println!("   -> Success: Service '{}' started.", service_name),
+        Err(e) => {
+            eprintln!(
+                "   -> Error: Failed to start service: {}. Halting example.",
+                e
+            );
+            return;
+        }
+    }
+
+    thread::sleep(Duration::from_secs(2));
+
+    // 2. Try to start the service again while it's already running
+    println!("\n2. Trying to start the *same service* again...");
+    match manager.start(&service_config) {
+        Ok(()) => println!("   -> Unexpected Success: Service started again."),
+        Err(e) => eprintln!(
+            "   -> Expected Error: {}. The manager should detect it is already running.",
+            e
+        ),
+    }
+
+    // 3. Let it run for a bit
+    println!("\n3. Letting the service run for 5 seconds...");
+    thread::sleep(Duration::from_secs(5));
+
+    // 4. Remove the service without stopping it first
+    // The `remove` function is designed to stop the service if it's running.
+    println!("\n4. Removing the service without explicitly stopping it first...");
+    match manager.remove(service_name) {
+        Ok(()) => println!("   -> Success: Service was stopped and removed."),
+        Err(e) => eprintln!("   -> Error: Failed to remove service: {}", e),
+    }
+
+    // 5. Try to stop the service after it has been removed
+    println!("\n5. Trying to stop the service that was just removed...");
+    match manager.stop(service_name) {
+        Ok(()) => println!("   -> Unexpected Success: Stopped a removed service."),
+        Err(e) => eprintln!(
+            "   -> Expected Error: {}. The manager knows the service is gone.",
+            e
+        ),
+    }
+
+    // 6. Try to remove the service again
+    println!("\n6. Trying to remove the service again...");
+    match manager.remove(service_name) {
+        Ok(()) => println!("   -> Unexpected Success: Removed a non-existent service."),
+        Err(e) => eprintln!(
+            "   -> Expected Error: {}. The manager correctly reports it's not found.",
+            e
+        ),
+    }
+
+    println!("\n--- Spaghetti Example Finished ---");
+}

_archive/service_manager/examples/simple_service.rs

@@ -0,0 +1,110 @@
+use sal_service_manager::{create_service_manager, ServiceConfig};
+use std::collections::HashMap;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    // Initialize logging to see socket discovery in action
+    env_logger::init();
+
+    // 1. Create a service manager for the current platform
+    let manager = match create_service_manager() {
+        Ok(manager) => manager,
+        Err(e) => {
+            eprintln!("Error: Failed to create service manager: {}", e);
+            return;
+        }
+    };
+
+    // 2. Define the configuration for our new service
+    let service_name = "com.herocode.examples.simpleservice";
+    let service_config = ServiceConfig {
+        name: service_name.to_string(),
+        // A simple command that runs in a loop
+        binary_path: "/bin/sh".to_string(),
+        args: vec![
+            "-c".to_string(),
+            "while true; do echo 'Simple service is running...'; date; sleep 5; done".to_string(),
+        ],
+        working_directory: None,
+        environment: HashMap::new(),
+        auto_restart: false,
+    };
+
+    println!("--- Service Manager Example ---");
+
+    // Cleanup from previous runs, if necessary
+    if let Ok(true) = manager.exists(service_name) {
+        println!(
+            "Service '{}' already exists. Cleaning up before starting.",
+            service_name
+        );
+        if let Err(e) = manager.stop(service_name) {
+            println!(
+                "Note: could not stop existing service (it might not be running): {}",
+                e
+            );
+        }
+        if let Err(e) = manager.remove(service_name) {
+            eprintln!("Error: failed to remove existing service: {}", e);
+            return;
+        }
+        println!("Cleanup complete.");
+    }
+
+    // 3. Start the service (creates and starts in one step)
+    println!("\n1. Starting service: '{}'", service_name);
+    match manager.start(&service_config) {
+        Ok(()) => println!("Service '{}' started successfully.", service_name),
+        Err(e) => {
+            eprintln!("Error: Failed to start service '{}': {}", service_name, e);
+            return;
+        }
+    }
+
+    // Give it a moment to run
+    println!("\nWaiting for 2 seconds for the service to initialize...");
+    thread::sleep(Duration::from_secs(2));
+
+    // 4. Check the status of the service
+    println!("\n2. Checking service status...");
+    match manager.status(service_name) {
+        Ok(status) => println!("Service status: {:?}", status),
+        Err(e) => eprintln!(
+            "Error: Failed to get status for service '{}': {}",
+            service_name, e
+        ),
+    }
+
+    println!("\nLetting the service run for 10 seconds. Check logs if you can.");
+    thread::sleep(Duration::from_secs(10));
+
+    // 5. Stop the service
+    println!("\n3. Stopping service: '{}'", service_name);
+    match manager.stop(service_name) {
+        Ok(()) => println!("Service '{}' stopped successfully.", service_name),
+        Err(e) => eprintln!("Error: Failed to stop service '{}': {}", service_name, e),
+    }
+
+    println!("\nWaiting for 2 seconds for the service to stop...");
+    thread::sleep(Duration::from_secs(2));
+
+    // Check status again
+    println!("\n4. Checking status after stopping...");
+    match manager.status(service_name) {
+        Ok(status) => println!("Service status: {:?}", status),
+        Err(e) => eprintln!(
+            "Error: Failed to get status for service '{}': {}",
+            service_name, e
+        ),
+    }
+
+    // 6. Remove the service
+    println!("\n5. Removing service: '{}'", service_name);
+    match manager.remove(service_name) {
+        Ok(()) => println!("Service '{}' removed successfully.", service_name),
+        Err(e) => eprintln!("Error: Failed to remove service '{}': {}", service_name, e),
+    }
+
+    println!("\n--- Example Finished ---");
+}

_archive/service_manager/examples/socket_discovery_test.rs

@@ -0,0 +1,47 @@
+//! Socket Discovery Test
+//!
+//! This example demonstrates the zinit socket discovery functionality.
+//! It shows how the service manager finds available zinit sockets.
+
+use sal_service_manager::create_service_manager;
+
+fn main() {
+    // Initialize logging to see socket discovery in action
+    env_logger::init();
+    
+    println!("=== Zinit Socket Discovery Test ===");
+    println!("This test demonstrates how the service manager discovers zinit sockets.");
+    println!();
+    
+    // Test environment variable
+    if let Ok(socket_path) = std::env::var("ZINIT_SOCKET_PATH") {
+        println!("🔍 ZINIT_SOCKET_PATH environment variable set to: {}", socket_path);
+    } else {
+        println!("🔍 ZINIT_SOCKET_PATH environment variable not set");
+    }
+    println!();
+    
+    println!("🚀 Creating service manager...");
+    match create_service_manager() {
+        Ok(_manager) => {
+            println!("✅ Service manager created successfully!");
+            
+            #[cfg(target_os = "macos")]
+            println!("📱 Platform: macOS - Using launchctl");
+            
+            #[cfg(target_os = "linux")]
+            println!("🐧 Platform: Linux - Check logs above for socket discovery details");
+        }
+        Err(e) => {
+            println!("❌ Failed to create service manager: {}", e);
+        }
+    }
+    
+    println!();
+    println!("=== Test Complete ===");
+    println!();
+    println!("To test zinit socket discovery on Linux:");
+    println!("1. Start zinit: zinit -s /tmp/zinit.sock init");
+    println!("2. Run with logging: RUST_LOG=debug cargo run --example socket_discovery_test -p sal-service-manager");
+    println!("3. Or set custom path: ZINIT_SOCKET_PATH=/custom/path.sock RUST_LOG=debug cargo run --example socket_discovery_test -p sal-service-manager");
+}

_archive/service_manager/src/launchctl.rs

@@ -0,0 +1,492 @@
+use crate::{ServiceConfig, ServiceManager, ServiceManagerError, ServiceStatus};
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use tokio::process::Command;
+use tokio::runtime::Runtime;
+
+// Shared runtime for async operations - production-safe initialization
+static ASYNC_RUNTIME: Lazy<Option<Runtime>> = Lazy::new(|| Runtime::new().ok());
+
+/// Get the async runtime, creating a temporary one if the static runtime failed
+fn get_runtime() -> Result<Runtime, ServiceManagerError> {
+    // Try to use the static runtime first
+    if let Some(_runtime) = ASYNC_RUNTIME.as_ref() {
+        // We can't return a reference to the static runtime because we need ownership
+        // for block_on, so we create a new one. This is a reasonable trade-off for safety.
+        Runtime::new().map_err(|e| {
+            ServiceManagerError::Other(format!("Failed to create async runtime: {}", e))
+        })
+    } else {
+        // Static runtime failed, try to create a new one
+        Runtime::new().map_err(|e| {
+            ServiceManagerError::Other(format!("Failed to create async runtime: {}", e))
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct LaunchctlServiceManager {
+    service_prefix: String,
+}
+
+#[derive(Serialize, Deserialize)]
+struct LaunchDaemon {
+    #[serde(rename = "Label")]
+    label: String,
+    #[serde(rename = "ProgramArguments")]
+    program_arguments: Vec<String>,
+    #[serde(rename = "WorkingDirectory", skip_serializing_if = "Option::is_none")]
+    working_directory: Option<String>,
+    #[serde(
+        rename = "EnvironmentVariables",
+        skip_serializing_if = "Option::is_none"
+    )]
+    environment_variables: Option<HashMap<String, String>>,
+    #[serde(rename = "KeepAlive", skip_serializing_if = "Option::is_none")]
+    keep_alive: Option<bool>,
+    #[serde(rename = "RunAtLoad")]
+    run_at_load: bool,
+    #[serde(rename = "StandardOutPath", skip_serializing_if = "Option::is_none")]
+    standard_out_path: Option<String>,
+    #[serde(rename = "StandardErrorPath", skip_serializing_if = "Option::is_none")]
+    standard_error_path: Option<String>,
+}
+
+impl LaunchctlServiceManager {
+    pub fn new() -> Self {
+        Self {
+            service_prefix: "tf.ourworld.circles".to_string(),
+        }
+    }
+
+    fn get_service_label(&self, service_name: &str) -> String {
+        format!("{}.{}", self.service_prefix, service_name)
+    }
+
+    fn get_plist_path(&self, service_name: &str) -> PathBuf {
+        let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
+        PathBuf::from(home)
+            .join("Library")
+            .join("LaunchAgents")
+            .join(format!("{}.plist", self.get_service_label(service_name)))
+    }
+
+    fn get_log_path(&self, service_name: &str) -> PathBuf {
+        let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
+        PathBuf::from(home)
+            .join("Library")
+            .join("Logs")
+            .join("circles")
+            .join(format!("{}.log", service_name))
+    }
+
+    async fn create_plist(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError> {
+        let label = self.get_service_label(&config.name);
+        let plist_path = self.get_plist_path(&config.name);
+        let log_path = self.get_log_path(&config.name);
+
+        // Ensure the LaunchAgents directory exists
+        if let Some(parent) = plist_path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        // Ensure the logs directory exists
+        if let Some(parent) = log_path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let mut program_arguments = vec![config.binary_path.clone()];
+        program_arguments.extend(config.args.clone());
+
+        let launch_daemon = LaunchDaemon {
+            label: label.clone(),
+            program_arguments,
+            working_directory: config.working_directory.clone(),
+            environment_variables: if config.environment.is_empty() {
+                None
+            } else {
+                Some(config.environment.clone())
+            },
+            keep_alive: if config.auto_restart {
+                Some(true)
+            } else {
+                None
+            },
+            run_at_load: true,
+            standard_out_path: Some(log_path.to_string_lossy().to_string()),
+            standard_error_path: Some(log_path.to_string_lossy().to_string()),
+        };
+
+        let mut plist_content = Vec::new();
+        plist::to_writer_xml(&mut plist_content, &launch_daemon)
+            .map_err(|e| ServiceManagerError::Other(format!("Failed to serialize plist: {}", e)))?;
+        let plist_content = String::from_utf8(plist_content).map_err(|e| {
+            ServiceManagerError::Other(format!("Failed to convert plist to string: {}", e))
+        })?;
+
+        tokio::fs::write(&plist_path, plist_content).await?;
+
+        Ok(())
+    }
+
+    async fn run_launchctl(&self, args: &[&str]) -> Result<String, ServiceManagerError> {
+        let output = Command::new("launchctl").args(args).output().await?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(ServiceManagerError::Other(format!(
+                "launchctl command failed: {}",
+                stderr
+            )));
+        }
+
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    }
+
+    async fn wait_for_service_status(
+        &self,
+        service_name: &str,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        use tokio::time::{sleep, timeout, Duration};
+
+        let timeout_duration = Duration::from_secs(timeout_secs);
+        let poll_interval = Duration::from_millis(500);
+
+        let result = timeout(timeout_duration, async {
+            loop {
+                match self.status(service_name) {
+                    Ok(ServiceStatus::Running) => {
+                        return Ok(());
+                    }
+                    Ok(ServiceStatus::Failed) => {
+                        // Service failed, get error details from logs
+                        let logs = self.logs(service_name, Some(20)).unwrap_or_default();
+                        let error_msg = if logs.is_empty() {
+                            "Service failed to start (no logs available)".to_string()
+                        } else {
+                            // Extract error lines from logs
+                            let error_lines: Vec<&str> = logs
+                                .lines()
+                                .filter(|line| {
+                                    line.to_lowercase().contains("error")
+                                        || line.to_lowercase().contains("failed")
+                                })
+                                .take(3)
+                                .collect();
+
+                            if error_lines.is_empty() {
+                                format!(
+                                    "Service failed to start. Recent logs:\n{}",
+                                    logs.lines()
+                                        .rev()
+                                        .take(5)
+                                        .collect::<Vec<_>>()
+                                        .into_iter()
+                                        .rev()
+                                        .collect::<Vec<_>>()
+                                        .join("\n")
+                                )
+                            } else {
+                                format!(
+                                    "Service failed to start. Errors:\n{}",
+                                    error_lines.join("\n")
+                                )
+                            }
+                        };
+                        return Err(ServiceManagerError::StartFailed(
+                            service_name.to_string(),
+                            error_msg,
+                        ));
+                    }
+                    Ok(ServiceStatus::Stopped) | Ok(ServiceStatus::Unknown) => {
+                        // Still starting, continue polling
+                        sleep(poll_interval).await;
+                    }
+                    Err(ServiceManagerError::ServiceNotFound(_)) => {
+                        return Err(ServiceManagerError::ServiceNotFound(
+                            service_name.to_string(),
+                        ));
+                    }
+                    Err(e) => {
+                        return Err(e);
+                    }
+                }
+            }
+        })
+        .await;
+
+        match result {
+            Ok(Ok(())) => Ok(()),
+            Ok(Err(e)) => Err(e),
+            Err(_) => Err(ServiceManagerError::StartFailed(
+                service_name.to_string(),
+                format!("Service did not start within {} seconds", timeout_secs),
+            )),
+        }
+    }
+}
+
+impl ServiceManager for LaunchctlServiceManager {
+    fn exists(&self, service_name: &str) -> Result<bool, ServiceManagerError> {
+        let plist_path = self.get_plist_path(service_name);
+        Ok(plist_path.exists())
+    }
+
+    fn start(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError> {
+        // Use production-safe runtime for async operations
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let label = self.get_service_label(&config.name);
+
+            // Check if service is already loaded
+            let list_output = self.run_launchctl(&["list"]).await?;
+            if list_output.contains(&label) {
+                return Err(ServiceManagerError::ServiceAlreadyExists(
+                    config.name.clone(),
+                ));
+            }
+
+            // Create the plist file
+            self.create_plist(config).await?;
+
+            // Load the service
+            let plist_path = self.get_plist_path(&config.name);
+            self.run_launchctl(&["load", &plist_path.to_string_lossy()])
+                .await
+                .map_err(|e| {
+                    ServiceManagerError::StartFailed(config.name.clone(), e.to_string())
+                })?;
+
+            Ok(())
+        })
+    }
+
+    fn start_existing(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let label = self.get_service_label(service_name);
+            let plist_path = self.get_plist_path(service_name);
+
+            // Check if plist file exists
+            if !plist_path.exists() {
+                return Err(ServiceManagerError::ServiceNotFound(
+                    service_name.to_string(),
+                ));
+            }
+
+            // Check if service is already loaded and running
+            let list_output = self.run_launchctl(&["list"]).await?;
+            if list_output.contains(&label) {
+                // Service is loaded, check if it's running
+                match self.status(service_name)? {
+                    ServiceStatus::Running => {
+                        return Ok(()); // Already running, nothing to do
+                    }
+                    _ => {
+                        // Service is loaded but not running, try to start it
+                        self.run_launchctl(&["start", &label]).await.map_err(|e| {
+                            ServiceManagerError::StartFailed(
+                                service_name.to_string(),
+                                e.to_string(),
+                            )
+                        })?;
+                        return Ok(());
+                    }
+                }
+            }
+
+            // Service is not loaded, load it
+            self.run_launchctl(&["load", &plist_path.to_string_lossy()])
+                .await
+                .map_err(|e| {
+                    ServiceManagerError::StartFailed(service_name.to_string(), e.to_string())
+                })?;
+
+            Ok(())
+        })
+    }
+
+    fn start_and_confirm(
+        &self,
+        config: &ServiceConfig,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // First start the service
+        self.start(config)?;
+
+        // Then wait for confirmation using production-safe runtime
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            self.wait_for_service_status(&config.name, timeout_secs)
+                .await
+        })
+    }
+
+    fn start_existing_and_confirm(
+        &self,
+        service_name: &str,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // First start the existing service
+        self.start_existing(service_name)?;
+
+        // Then wait for confirmation using production-safe runtime
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            self.wait_for_service_status(service_name, timeout_secs)
+                .await
+        })
+    }
+
+    fn stop(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let _label = self.get_service_label(service_name);
+            let plist_path = self.get_plist_path(service_name);
+
+            // Unload the service
+            self.run_launchctl(&["unload", &plist_path.to_string_lossy()])
+                .await
+                .map_err(|e| {
+                    ServiceManagerError::StopFailed(service_name.to_string(), e.to_string())
+                })?;
+
+            Ok(())
+        })
+    }
+
+    fn restart(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        // For launchctl, we stop and start
+        if let Err(e) = self.stop(service_name) {
+            // If stop fails because service doesn't exist, that's ok for restart
+            if !matches!(e, ServiceManagerError::ServiceNotFound(_)) {
+                return Err(ServiceManagerError::RestartFailed(
+                    service_name.to_string(),
+                    e.to_string(),
+                ));
+            }
+        }
+
+        // We need the config to restart, but we don't have it stored
+        // For now, return an error - in a real implementation we might store configs
+        Err(ServiceManagerError::RestartFailed(
+            service_name.to_string(),
+            "Restart requires re-providing service configuration".to_string(),
+        ))
+    }
+
+    fn status(&self, service_name: &str) -> Result<ServiceStatus, ServiceManagerError> {
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let label = self.get_service_label(service_name);
+            let plist_path = self.get_plist_path(service_name);
+
+            // First check if the plist file exists
+            if !plist_path.exists() {
+                return Err(ServiceManagerError::ServiceNotFound(
+                    service_name.to_string(),
+                ));
+            }
+
+            let list_output = self.run_launchctl(&["list"]).await?;
+
+            if !list_output.contains(&label) {
+                return Ok(ServiceStatus::Stopped);
+            }
+
+            // Get detailed status
+            match self.run_launchctl(&["list", &label]).await {
+                Ok(output) => {
+                    if output.contains("\"PID\" = ") {
+                        Ok(ServiceStatus::Running)
+                    } else if output.contains("\"LastExitStatus\" = ") {
+                        Ok(ServiceStatus::Failed)
+                    } else {
+                        Ok(ServiceStatus::Unknown)
+                    }
+                }
+                Err(_) => Ok(ServiceStatus::Stopped),
+            }
+        })
+    }
+
+    fn logs(
+        &self,
+        service_name: &str,
+        lines: Option<usize>,
+    ) -> Result<String, ServiceManagerError> {
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let log_path = self.get_log_path(service_name);
+
+            if !log_path.exists() {
+                return Ok(String::new());
+            }
+
+            match lines {
+                Some(n) => {
+                    let output = Command::new("tail")
+                        .args(&["-n", &n.to_string(), &log_path.to_string_lossy()])
+                        .output()
+                        .await?;
+                    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+                }
+                None => {
+                    let content = tokio::fs::read_to_string(&log_path).await?;
+                    Ok(content)
+                }
+            }
+        })
+    }
+
+    fn list(&self) -> Result<Vec<String>, ServiceManagerError> {
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let list_output = self.run_launchctl(&["list"]).await?;
+
+            let services: Vec<String> = list_output
+                .lines()
+                .filter_map(|line| {
+                    if line.contains(&self.service_prefix) {
+                        // Extract service name from label
+                        line.split_whitespace()
+                            .last()
+                            .and_then(|label| {
+                                label.strip_prefix(&format!("{}.", self.service_prefix))
+                            })
+                            .map(|s| s.to_string())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            Ok(services)
+        })
+    }
+
+    fn remove(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        // Try to stop the service first, but don't fail if it's already stopped or doesn't exist
+        if let Err(e) = self.stop(service_name) {
+            // Log the error but continue with removal
+            log::warn!(
+                "Failed to stop service '{}' before removal: {}",
+                service_name,
+                e
+            );
+        }
+
+        // Remove the plist file using production-safe runtime
+        let runtime = get_runtime()?;
+        runtime.block_on(async {
+            let plist_path = self.get_plist_path(service_name);
+            if plist_path.exists() {
+                tokio::fs::remove_file(&plist_path).await?;
+            }
+            Ok(())
+        })
+    }
+}

_archive/service_manager/src/lib.rs

@@ -0,0 +1,301 @@
+use std::collections::HashMap;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ServiceManagerError {
+    #[error("Service '{0}' not found")]
+    ServiceNotFound(String),
+    #[error("Service '{0}' already exists")]
+    ServiceAlreadyExists(String),
+    #[error("Failed to start service '{0}': {1}")]
+    StartFailed(String, String),
+    #[error("Failed to stop service '{0}': {1}")]
+    StopFailed(String, String),
+    #[error("Failed to restart service '{0}': {1}")]
+    RestartFailed(String, String),
+    #[error("Failed to get logs for service '{0}': {1}")]
+    LogsFailed(String, String),
+    #[error("IO error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Service manager error: {0}")]
+    Other(String),
+}
+
+#[derive(Debug, Clone)]
+pub struct ServiceConfig {
+    pub name: String,
+    pub binary_path: String,
+    pub args: Vec<String>,
+    pub working_directory: Option<String>,
+    pub environment: HashMap<String, String>,
+    pub auto_restart: bool,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ServiceStatus {
+    Running,
+    Stopped,
+    Failed,
+    Unknown,
+}
+
+pub trait ServiceManager: Send + Sync {
+    /// Check if a service exists
+    fn exists(&self, service_name: &str) -> Result<bool, ServiceManagerError>;
+
+    /// Start a service with the given configuration
+    fn start(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError>;
+
+    /// Start an existing service by name (load existing plist/config)
+    fn start_existing(&self, service_name: &str) -> Result<(), ServiceManagerError>;
+
+    /// Start a service and wait for confirmation that it's running or failed
+    fn start_and_confirm(
+        &self,
+        config: &ServiceConfig,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError>;
+
+    /// Start an existing service and wait for confirmation that it's running or failed
+    fn start_existing_and_confirm(
+        &self,
+        service_name: &str,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError>;
+
+    /// Stop a service by name
+    fn stop(&self, service_name: &str) -> Result<(), ServiceManagerError>;
+
+    /// Restart a service by name
+    fn restart(&self, service_name: &str) -> Result<(), ServiceManagerError>;
+
+    /// Get the status of a service
+    fn status(&self, service_name: &str) -> Result<ServiceStatus, ServiceManagerError>;
+
+    /// Get logs for a service
+    fn logs(&self, service_name: &str, lines: Option<usize>)
+        -> Result<String, ServiceManagerError>;
+
+    /// List all managed services
+    fn list(&self) -> Result<Vec<String>, ServiceManagerError>;
+
+    /// Remove a service configuration (stop if running)
+    fn remove(&self, service_name: &str) -> Result<(), ServiceManagerError>;
+}
+
+// Platform-specific implementations
+#[cfg(target_os = "macos")]
+mod launchctl;
+#[cfg(target_os = "macos")]
+pub use launchctl::LaunchctlServiceManager;
+
+#[cfg(target_os = "linux")]
+mod systemd;
+#[cfg(target_os = "linux")]
+pub use systemd::SystemdServiceManager;
+
+mod zinit;
+pub use zinit::ZinitServiceManager;
+
+#[cfg(feature = "rhai")]
+pub mod rhai;
+
+/// Discover available zinit socket paths
+///
+/// This function checks for zinit sockets in the following order:
+/// 1. Environment variable ZINIT_SOCKET_PATH (if set)
+/// 2. Common socket locations with connectivity testing
+///
+/// # Returns
+///
+/// Returns the first working socket path found, or None if no working zinit server is detected.
+#[cfg(target_os = "linux")]
+fn discover_zinit_socket() -> Option<String> {
+    // First check environment variable
+    if let Ok(env_socket_path) = std::env::var("ZINIT_SOCKET_PATH") {
+        log::debug!("Checking ZINIT_SOCKET_PATH: {}", env_socket_path);
+        if test_zinit_socket(&env_socket_path) {
+            log::info!(
+                "Using zinit socket from ZINIT_SOCKET_PATH: {}",
+                env_socket_path
+            );
+            return Some(env_socket_path);
+        } else {
+            log::warn!(
+                "ZINIT_SOCKET_PATH specified but socket is not accessible: {}",
+                env_socket_path
+            );
+        }
+    }
+
+    // Try common socket locations
+    let common_paths = [
+        "/var/run/zinit.sock",
+        "/tmp/zinit.sock",
+        "/run/zinit.sock",
+        "./zinit.sock",
+    ];
+
+    log::debug!("Discovering zinit socket from common locations...");
+    for path in &common_paths {
+        log::debug!("Testing socket path: {}", path);
+        if test_zinit_socket(path) {
+            log::info!("Found working zinit socket at: {}", path);
+            return Some(path.to_string());
+        }
+    }
+
+    log::debug!("No working zinit socket found");
+    None
+}
+
+/// Test if a zinit socket is accessible and responsive
+///
+/// This function attempts to create a ZinitServiceManager and perform a basic
+/// connectivity test by listing services.
+#[cfg(target_os = "linux")]
+fn test_zinit_socket(socket_path: &str) -> bool {
+    // Check if socket file exists first
+    if !std::path::Path::new(socket_path).exists() {
+        log::debug!("Socket file does not exist: {}", socket_path);
+        return false;
+    }
+
+    // Try to create a manager and test basic connectivity
+    match ZinitServiceManager::new(socket_path) {
+        Ok(manager) => {
+            // Test basic connectivity by trying to list services
+            match manager.list() {
+                Ok(_) => {
+                    log::debug!("Socket {} is responsive", socket_path);
+                    true
+                }
+                Err(e) => {
+                    log::debug!("Socket {} exists but not responsive: {}", socket_path, e);
+                    false
+                }
+            }
+        }
+        Err(e) => {
+            log::debug!("Failed to create manager for socket {}: {}", socket_path, e);
+            false
+        }
+    }
+}
+
+/// Create a service manager appropriate for the current platform
+///
+/// - On macOS: Uses launchctl for service management
+/// - On Linux: Uses zinit for service management with systemd fallback
+///
+/// # Returns
+///
+/// Returns a Result containing the service manager or an error if initialization fails.
+/// On Linux, it first tries to discover a working zinit socket. If no zinit server is found,
+/// it will fall back to systemd.
+///
+/// # Environment Variables
+///
+/// - `ZINIT_SOCKET_PATH`: Specifies the zinit socket path (Linux only)
+///
+/// # Errors
+///
+/// Returns `ServiceManagerError` if:
+/// - The platform is not supported (Windows, etc.)
+/// - Service manager initialization fails on all available backends
+pub fn create_service_manager() -> Result<Box<dyn ServiceManager>, ServiceManagerError> {
+    #[cfg(target_os = "macos")]
+    {
+        Ok(Box::new(LaunchctlServiceManager::new()))
+    }
+    #[cfg(target_os = "linux")]
+    {
+        // Try to discover a working zinit socket
+        if let Some(socket_path) = discover_zinit_socket() {
+            match ZinitServiceManager::new(&socket_path) {
+                Ok(zinit_manager) => {
+                    log::info!("Using zinit service manager with socket: {}", socket_path);
+                    return Ok(Box::new(zinit_manager));
+                }
+                Err(zinit_error) => {
+                    log::warn!(
+                        "Failed to create zinit manager for discovered socket {}: {}",
+                        socket_path,
+                        zinit_error
+                    );
+                }
+            }
+        } else {
+            log::info!("No running zinit server detected. To use zinit, start it with: zinit -s /tmp/zinit.sock init");
+        }
+
+        // Fallback to systemd
+        log::info!("Falling back to systemd service manager");
+        Ok(Box::new(SystemdServiceManager::new()))
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    {
+        Err(ServiceManagerError::Other(
+            "Service manager not implemented for this platform".to_string(),
+        ))
+    }
+}
+
+/// Create a service manager for zinit with a custom socket path
+///
+/// This is useful when zinit is running with a non-default socket path
+pub fn create_zinit_service_manager(
+    socket_path: &str,
+) -> Result<Box<dyn ServiceManager>, ServiceManagerError> {
+    Ok(Box::new(ZinitServiceManager::new(socket_path)?))
+}
+
+/// Create a service manager for systemd (Linux alternative)
+///
+/// This creates a systemd-based service manager as an alternative to zinit on Linux
+#[cfg(target_os = "linux")]
+pub fn create_systemd_service_manager() -> Box<dyn ServiceManager> {
+    Box::new(SystemdServiceManager::new())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_service_manager() {
+        // This test ensures the service manager can be created without panicking
+        let result = create_service_manager();
+        assert!(result.is_ok(), "Service manager creation should succeed");
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn test_socket_discovery_with_env_var() {
+        // Test that environment variable is respected
+        std::env::set_var("ZINIT_SOCKET_PATH", "/test/path.sock");
+
+        // The discover function should check the env var first
+        // Since the socket doesn't exist, it should return None, but we can't test
+        // the actual discovery logic without a real socket
+
+        std::env::remove_var("ZINIT_SOCKET_PATH");
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn test_socket_discovery_without_env_var() {
+        // Ensure env var is not set
+        std::env::remove_var("ZINIT_SOCKET_PATH");
+
+        // The discover function should try common paths
+        // Since no zinit is running, it should return None
+        let result = discover_zinit_socket();
+
+        // This is expected to be None in test environment
+        assert!(
+            result.is_none(),
+            "Should return None when no zinit server is running"
+        );
+    }
+}

_archive/service_manager/src/rhai.rs

@@ -0,0 +1,256 @@
+//! Rhai integration for the service manager module
+//!
+//! This module provides Rhai scripting support for service management operations.
+
+use crate::{create_service_manager, ServiceConfig, ServiceManager};
+use rhai::{Engine, EvalAltResult, Map};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// A wrapper around ServiceManager that can be used in Rhai
+#[derive(Clone)]
+pub struct RhaiServiceManager {
+    inner: Arc<Box<dyn ServiceManager>>,
+}
+
+impl RhaiServiceManager {
+    pub fn new() -> Result<Self, Box<EvalAltResult>> {
+        let manager = create_service_manager()
+            .map_err(|e| format!("Failed to create service manager: {}", e))?;
+        Ok(Self {
+            inner: Arc::new(manager),
+        })
+    }
+}
+
+/// Register the service manager module with a Rhai engine
+pub fn register_service_manager_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Factory function to create service manager
+    engine.register_type::<RhaiServiceManager>();
+    engine.register_fn(
+        "create_service_manager",
+        || -> Result<RhaiServiceManager, Box<EvalAltResult>> { RhaiServiceManager::new() },
+    );
+
+    // Service management functions
+    engine.register_fn(
+        "start",
+        |manager: &mut RhaiServiceManager, config: Map| -> Result<(), Box<EvalAltResult>> {
+            let service_config = map_to_service_config(config)?;
+            manager
+                .inner
+                .start(&service_config)
+                .map_err(|e| format!("Failed to start service: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "stop",
+        |manager: &mut RhaiServiceManager,
+         service_name: String|
+         -> Result<(), Box<EvalAltResult>> {
+            manager
+                .inner
+                .stop(&service_name)
+                .map_err(|e| format!("Failed to stop service: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "restart",
+        |manager: &mut RhaiServiceManager,
+         service_name: String|
+         -> Result<(), Box<EvalAltResult>> {
+            manager
+                .inner
+                .restart(&service_name)
+                .map_err(|e| format!("Failed to restart service: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "status",
+        |manager: &mut RhaiServiceManager,
+         service_name: String|
+         -> Result<String, Box<EvalAltResult>> {
+            let status = manager
+                .inner
+                .status(&service_name)
+                .map_err(|e| format!("Failed to get service status: {}", e))?;
+            Ok(format!("{:?}", status))
+        },
+    );
+
+    engine.register_fn(
+        "logs",
+        |manager: &mut RhaiServiceManager,
+         service_name: String,
+         lines: i64|
+         -> Result<String, Box<EvalAltResult>> {
+            let lines_opt = if lines > 0 {
+                Some(lines as usize)
+            } else {
+                None
+            };
+            manager
+                .inner
+                .logs(&service_name, lines_opt)
+                .map_err(|e| format!("Failed to get service logs: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "list",
+        |manager: &mut RhaiServiceManager| -> Result<Vec<String>, Box<EvalAltResult>> {
+            manager
+                .inner
+                .list()
+                .map_err(|e| format!("Failed to list services: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "remove",
+        |manager: &mut RhaiServiceManager,
+         service_name: String|
+         -> Result<(), Box<EvalAltResult>> {
+            manager
+                .inner
+                .remove(&service_name)
+                .map_err(|e| format!("Failed to remove service: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "exists",
+        |manager: &mut RhaiServiceManager,
+         service_name: String|
+         -> Result<bool, Box<EvalAltResult>> {
+            manager
+                .inner
+                .exists(&service_name)
+                .map_err(|e| format!("Failed to check if service exists: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "start_and_confirm",
+        |manager: &mut RhaiServiceManager,
+         config: Map,
+         timeout_secs: i64|
+         -> Result<(), Box<EvalAltResult>> {
+            let service_config = map_to_service_config(config)?;
+            let timeout = if timeout_secs > 0 {
+                timeout_secs as u64
+            } else {
+                30
+            };
+            manager
+                .inner
+                .start_and_confirm(&service_config, timeout)
+                .map_err(|e| format!("Failed to start and confirm service: {}", e).into())
+        },
+    );
+
+    engine.register_fn(
+        "start_existing_and_confirm",
+        |manager: &mut RhaiServiceManager,
+         service_name: String,
+         timeout_secs: i64|
+         -> Result<(), Box<EvalAltResult>> {
+            let timeout = if timeout_secs > 0 {
+                timeout_secs as u64
+            } else {
+                30
+            };
+            manager
+                .inner
+                .start_existing_and_confirm(&service_name, timeout)
+                .map_err(|e| format!("Failed to start existing service and confirm: {}", e).into())
+        },
+    );
+
+    Ok(())
+}
+
+/// Convert a Rhai Map to a ServiceConfig
+fn map_to_service_config(map: Map) -> Result<ServiceConfig, Box<EvalAltResult>> {
+    let name = map
+        .get("name")
+        .and_then(|v| v.clone().into_string().ok())
+        .ok_or("Service config must have a 'name' field")?;
+
+    let binary_path = map
+        .get("binary_path")
+        .and_then(|v| v.clone().into_string().ok())
+        .ok_or("Service config must have a 'binary_path' field")?;
+
+    let args = map
+        .get("args")
+        .and_then(|v| v.clone().try_cast::<rhai::Array>())
+        .map(|arr| {
+            arr.into_iter()
+                .filter_map(|v| v.into_string().ok())
+                .collect::<Vec<String>>()
+        })
+        .unwrap_or_default();
+
+    let working_directory = map
+        .get("working_directory")
+        .and_then(|v| v.clone().into_string().ok());
+
+    let environment = map
+        .get("environment")
+        .and_then(|v| v.clone().try_cast::<Map>())
+        .map(|env_map| {
+            env_map
+                .into_iter()
+                .filter_map(|(k, v)| v.into_string().ok().map(|val| (k.to_string(), val)))
+                .collect::<HashMap<String, String>>()
+        })
+        .unwrap_or_default();
+
+    let auto_restart = map
+        .get("auto_restart")
+        .and_then(|v| v.as_bool().ok())
+        .unwrap_or(false);
+
+    Ok(ServiceConfig {
+        name,
+        binary_path,
+        args,
+        working_directory,
+        environment,
+        auto_restart,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rhai::{Engine, Map};
+
+    #[test]
+    fn test_register_service_manager_module() {
+        let mut engine = Engine::new();
+        register_service_manager_module(&mut engine).unwrap();
+
+        // Test that the functions are registered
+        // Note: Rhai doesn't expose a public API to check if functions are registered
+        // So we'll just verify the module registration doesn't panic
+        assert!(true);
+    }
+
+    #[test]
+    fn test_map_to_service_config() {
+        let mut map = Map::new();
+        map.insert("name".into(), "test-service".into());
+        map.insert("binary_path".into(), "/bin/echo".into());
+        map.insert("auto_restart".into(), true.into());
+
+        let config = map_to_service_config(map).unwrap();
+        assert_eq!(config.name, "test-service");
+        assert_eq!(config.binary_path, "/bin/echo");
+        assert_eq!(config.auto_restart, true);
+    }
+}

_archive/service_manager/src/systemd.rs

@@ -0,0 +1,434 @@
+use crate::{ServiceConfig, ServiceManager, ServiceManagerError, ServiceStatus};
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+
+#[derive(Debug)]
+pub struct SystemdServiceManager {
+    service_prefix: String,
+    user_mode: bool,
+}
+
+impl SystemdServiceManager {
+    pub fn new() -> Self {
+        Self {
+            service_prefix: "sal".to_string(),
+            user_mode: true, // Default to user services for safety
+        }
+    }
+
+    pub fn new_system() -> Self {
+        Self {
+            service_prefix: "sal".to_string(),
+            user_mode: false, // System-wide services (requires root)
+        }
+    }
+
+    fn get_service_name(&self, service_name: &str) -> String {
+        format!("{}-{}.service", self.service_prefix, service_name)
+    }
+
+    fn get_unit_file_path(&self, service_name: &str) -> PathBuf {
+        let service_file = self.get_service_name(service_name);
+        if self.user_mode {
+            // User service directory
+            let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
+            PathBuf::from(home)
+                .join(".config")
+                .join("systemd")
+                .join("user")
+                .join(service_file)
+        } else {
+            // System service directory
+            PathBuf::from("/etc/systemd/system").join(service_file)
+        }
+    }
+
+    fn run_systemctl(&self, args: &[&str]) -> Result<String, ServiceManagerError> {
+        let mut cmd = Command::new("systemctl");
+
+        if self.user_mode {
+            cmd.arg("--user");
+        }
+
+        cmd.args(args);
+
+        let output = cmd
+            .output()
+            .map_err(|e| ServiceManagerError::Other(format!("Failed to run systemctl: {}", e)))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(ServiceManagerError::Other(format!(
+                "systemctl command failed: {}",
+                stderr
+            )));
+        }
+
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    }
+
+    fn create_unit_file(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError> {
+        let unit_path = self.get_unit_file_path(&config.name);
+
+        // Ensure the directory exists
+        if let Some(parent) = unit_path.parent() {
+            fs::create_dir_all(parent).map_err(|e| {
+                ServiceManagerError::Other(format!("Failed to create unit directory: {}", e))
+            })?;
+        }
+
+        // Create the unit file content
+        let mut unit_content = String::new();
+        unit_content.push_str("[Unit]\n");
+        unit_content.push_str(&format!("Description={} service\n", config.name));
+        unit_content.push_str("After=network.target\n\n");
+
+        unit_content.push_str("[Service]\n");
+        unit_content.push_str("Type=simple\n");
+
+        // Build the ExecStart command
+        let mut exec_start = config.binary_path.clone();
+        for arg in &config.args {
+            exec_start.push(' ');
+            exec_start.push_str(arg);
+        }
+        unit_content.push_str(&format!("ExecStart={}\n", exec_start));
+
+        if let Some(working_dir) = &config.working_directory {
+            unit_content.push_str(&format!("WorkingDirectory={}\n", working_dir));
+        }
+
+        // Add environment variables
+        for (key, value) in &config.environment {
+            unit_content.push_str(&format!("Environment=\"{}={}\"\n", key, value));
+        }
+
+        if config.auto_restart {
+            unit_content.push_str("Restart=always\n");
+            unit_content.push_str("RestartSec=5\n");
+        }
+
+        unit_content.push_str("\n[Install]\n");
+        unit_content.push_str("WantedBy=default.target\n");
+
+        // Write the unit file
+        fs::write(&unit_path, unit_content)
+            .map_err(|e| ServiceManagerError::Other(format!("Failed to write unit file: {}", e)))?;
+
+        // Reload systemd to pick up the new unit file
+        self.run_systemctl(&["daemon-reload"])?;
+
+        Ok(())
+    }
+}
+
+impl ServiceManager for SystemdServiceManager {
+    fn exists(&self, service_name: &str) -> Result<bool, ServiceManagerError> {
+        let unit_path = self.get_unit_file_path(service_name);
+        Ok(unit_path.exists())
+    }
+
+    fn start(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError> {
+        let service_name = self.get_service_name(&config.name);
+
+        // Check if service already exists and is running
+        if self.exists(&config.name)? {
+            match self.status(&config.name)? {
+                ServiceStatus::Running => {
+                    return Err(ServiceManagerError::ServiceAlreadyExists(
+                        config.name.clone(),
+                    ));
+                }
+                _ => {
+                    // Service exists but not running, we can start it
+                }
+            }
+        } else {
+            // Create the unit file
+            self.create_unit_file(config)?;
+        }
+
+        // Enable and start the service
+        self.run_systemctl(&["enable", &service_name])
+            .map_err(|e| ServiceManagerError::StartFailed(config.name.clone(), e.to_string()))?;
+
+        self.run_systemctl(&["start", &service_name])
+            .map_err(|e| ServiceManagerError::StartFailed(config.name.clone(), e.to_string()))?;
+
+        Ok(())
+    }
+
+    fn start_existing(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if unit file exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Check if already running
+        match self.status(service_name)? {
+            ServiceStatus::Running => {
+                return Ok(()); // Already running, nothing to do
+            }
+            _ => {
+                // Start the service
+                self.run_systemctl(&["start", &service_unit]).map_err(|e| {
+                    ServiceManagerError::StartFailed(service_name.to_string(), e.to_string())
+                })?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn start_and_confirm(
+        &self,
+        config: &ServiceConfig,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // Start the service first
+        self.start(config)?;
+
+        // Wait for confirmation with timeout
+        let start_time = std::time::Instant::now();
+        let timeout_duration = std::time::Duration::from_secs(timeout_secs);
+
+        while start_time.elapsed() < timeout_duration {
+            match self.status(&config.name) {
+                Ok(ServiceStatus::Running) => return Ok(()),
+                Ok(ServiceStatus::Failed) => {
+                    return Err(ServiceManagerError::StartFailed(
+                        config.name.clone(),
+                        "Service failed to start".to_string(),
+                    ));
+                }
+                Ok(_) => {
+                    // Still starting, wait a bit
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                }
+                Err(_) => {
+                    // Service might not exist yet, wait a bit
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                }
+            }
+        }
+
+        Err(ServiceManagerError::StartFailed(
+            config.name.clone(),
+            format!("Service did not start within {} seconds", timeout_secs),
+        ))
+    }
+
+    fn start_existing_and_confirm(
+        &self,
+        service_name: &str,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // Start the existing service first
+        self.start_existing(service_name)?;
+
+        // Wait for confirmation with timeout
+        let start_time = std::time::Instant::now();
+        let timeout_duration = std::time::Duration::from_secs(timeout_secs);
+
+        while start_time.elapsed() < timeout_duration {
+            match self.status(service_name) {
+                Ok(ServiceStatus::Running) => return Ok(()),
+                Ok(ServiceStatus::Failed) => {
+                    return Err(ServiceManagerError::StartFailed(
+                        service_name.to_string(),
+                        "Service failed to start".to_string(),
+                    ));
+                }
+                Ok(_) => {
+                    // Still starting, wait a bit
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                }
+                Err(_) => {
+                    // Service might not exist yet, wait a bit
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                }
+            }
+        }
+
+        Err(ServiceManagerError::StartFailed(
+            service_name.to_string(),
+            format!("Service did not start within {} seconds", timeout_secs),
+        ))
+    }
+
+    fn stop(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if service exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Stop the service
+        self.run_systemctl(&["stop", &service_unit]).map_err(|e| {
+            ServiceManagerError::StopFailed(service_name.to_string(), e.to_string())
+        })?;
+
+        Ok(())
+    }
+
+    fn restart(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if service exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Restart the service
+        self.run_systemctl(&["restart", &service_unit])
+            .map_err(|e| {
+                ServiceManagerError::RestartFailed(service_name.to_string(), e.to_string())
+            })?;
+
+        Ok(())
+    }
+
+    fn status(&self, service_name: &str) -> Result<ServiceStatus, ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if service exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Get service status
+        let output = self
+            .run_systemctl(&["is-active", &service_unit])
+            .unwrap_or_else(|_| "unknown".to_string());
+
+        let status = match output.trim() {
+            "active" => ServiceStatus::Running,
+            "inactive" => ServiceStatus::Stopped,
+            "failed" => ServiceStatus::Failed,
+            _ => ServiceStatus::Unknown,
+        };
+
+        Ok(status)
+    }
+
+    fn logs(
+        &self,
+        service_name: &str,
+        lines: Option<usize>,
+    ) -> Result<String, ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if service exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Build journalctl command
+        let mut args = vec!["--unit", &service_unit, "--no-pager"];
+        let lines_arg;
+        if let Some(n) = lines {
+            lines_arg = format!("--lines={}", n);
+            args.push(&lines_arg);
+        }
+
+        // Use journalctl to get logs
+        let mut cmd = std::process::Command::new("journalctl");
+        if self.user_mode {
+            cmd.arg("--user");
+        }
+        cmd.args(&args);
+
+        let output = cmd.output().map_err(|e| {
+            ServiceManagerError::LogsFailed(
+                service_name.to_string(),
+                format!("Failed to run journalctl: {}", e),
+            )
+        })?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(ServiceManagerError::LogsFailed(
+                service_name.to_string(),
+                format!("journalctl command failed: {}", stderr),
+            ));
+        }
+
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    }
+
+    fn list(&self) -> Result<Vec<String>, ServiceManagerError> {
+        // List all services with our prefix
+        let output =
+            self.run_systemctl(&["list-units", "--type=service", "--all", "--no-pager"])?;
+
+        let mut services = Vec::new();
+        for line in output.lines() {
+            if line.contains(&format!("{}-", self.service_prefix)) {
+                // Extract service name from the line
+                if let Some(unit_name) = line.split_whitespace().next() {
+                    if let Some(service_name) = unit_name.strip_suffix(".service") {
+                        if let Some(name) =
+                            service_name.strip_prefix(&format!("{}-", self.service_prefix))
+                        {
+                            services.push(name.to_string());
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(services)
+    }
+
+    fn remove(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let service_unit = self.get_service_name(service_name);
+
+        // Check if service exists
+        if !self.exists(service_name)? {
+            return Err(ServiceManagerError::ServiceNotFound(
+                service_name.to_string(),
+            ));
+        }
+
+        // Try to stop the service first, but don't fail if it's already stopped
+        if let Err(e) = self.stop(service_name) {
+            log::warn!(
+                "Failed to stop service '{}' before removal: {}",
+                service_name,
+                e
+            );
+        }
+
+        // Disable the service
+        if let Err(e) = self.run_systemctl(&["disable", &service_unit]) {
+            log::warn!("Failed to disable service '{}': {}", service_name, e);
+        }
+
+        // Remove the unit file
+        let unit_path = self.get_unit_file_path(service_name);
+        if unit_path.exists() {
+            std::fs::remove_file(&unit_path).map_err(|e| {
+                ServiceManagerError::Other(format!("Failed to remove unit file: {}", e))
+            })?;
+        }
+
+        // Reload systemd to pick up the changes
+        self.run_systemctl(&["daemon-reload"])?;
+
+        Ok(())
+    }
+}

_archive/service_manager/src/zinit.rs

@@ -0,0 +1,379 @@
+use crate::{ServiceConfig, ServiceManager, ServiceManagerError, ServiceStatus};
+use once_cell::sync::Lazy;
+use serde_json::json;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::runtime::Runtime;
+use tokio::time::timeout;
+use zinit_client::{ServiceStatus as ZinitServiceStatus, ZinitClient, ZinitError};
+
+// Shared runtime for async operations - production-safe initialization
+static ASYNC_RUNTIME: Lazy<Option<Runtime>> = Lazy::new(|| Runtime::new().ok());
+
+/// Get the async runtime, creating a temporary one if the static runtime failed
+fn get_runtime() -> Result<Runtime, ServiceManagerError> {
+    // Try to use the static runtime first
+    if let Some(_runtime) = ASYNC_RUNTIME.as_ref() {
+        // We can't return a reference to the static runtime because we need ownership
+        // for block_on, so we create a new one. This is a reasonable trade-off for safety.
+        Runtime::new().map_err(|e| {
+            ServiceManagerError::Other(format!("Failed to create async runtime: {}", e))
+        })
+    } else {
+        // Static runtime failed, try to create a new one
+        Runtime::new().map_err(|e| {
+            ServiceManagerError::Other(format!("Failed to create async runtime: {}", e))
+        })
+    }
+}
+
+pub struct ZinitServiceManager {
+    client: Arc<ZinitClient>,
+}
+
+impl ZinitServiceManager {
+    pub fn new(socket_path: &str) -> Result<Self, ServiceManagerError> {
+        // Create the base zinit client directly
+        let client = Arc::new(ZinitClient::new(socket_path));
+
+        Ok(ZinitServiceManager { client })
+    }
+
+    /// Execute an async operation using the shared runtime or current context
+    fn execute_async<F, T>(&self, operation: F) -> Result<T, ServiceManagerError>
+    where
+        F: std::future::Future<Output = Result<T, ZinitError>> + Send + 'static,
+        T: Send + 'static,
+    {
+        // Check if we're already in a tokio runtime context
+        if let Ok(_handle) = tokio::runtime::Handle::try_current() {
+            // We're in an async context, use spawn_blocking to avoid nested runtime
+            let result = std::thread::spawn(
+                move || -> Result<Result<T, ZinitError>, ServiceManagerError> {
+                    let rt = Runtime::new().map_err(|e| {
+                        ServiceManagerError::Other(format!("Failed to create runtime: {}", e))
+                    })?;
+                    Ok(rt.block_on(operation))
+                },
+            )
+            .join()
+            .map_err(|_| ServiceManagerError::Other("Thread join failed".to_string()))?;
+            result?.map_err(|e| ServiceManagerError::Other(e.to_string()))
+        } else {
+            // No current runtime, use production-safe runtime
+            let runtime = get_runtime()?;
+            runtime
+                .block_on(operation)
+                .map_err(|e| ServiceManagerError::Other(e.to_string()))
+        }
+    }
+
+    /// Execute an async operation with timeout using the shared runtime or current context
+    fn execute_async_with_timeout<F, T>(
+        &self,
+        operation: F,
+        timeout_secs: u64,
+    ) -> Result<T, ServiceManagerError>
+    where
+        F: std::future::Future<Output = Result<T, ZinitError>> + Send + 'static,
+        T: Send + 'static,
+    {
+        let timeout_duration = Duration::from_secs(timeout_secs);
+        let timeout_op = timeout(timeout_duration, operation);
+
+        // Check if we're already in a tokio runtime context
+        if let Ok(_handle) = tokio::runtime::Handle::try_current() {
+            // We're in an async context, use spawn_blocking to avoid nested runtime
+            let result = std::thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                rt.block_on(timeout_op)
+            })
+            .join()
+            .map_err(|_| ServiceManagerError::Other("Thread join failed".to_string()))?;
+
+            result
+                .map_err(|_| {
+                    ServiceManagerError::Other(format!(
+                        "Operation timed out after {} seconds",
+                        timeout_secs
+                    ))
+                })?
+                .map_err(|e| ServiceManagerError::Other(e.to_string()))
+        } else {
+            // No current runtime, use production-safe runtime
+            let runtime = get_runtime()?;
+            runtime
+                .block_on(timeout_op)
+                .map_err(|_| {
+                    ServiceManagerError::Other(format!(
+                        "Operation timed out after {} seconds",
+                        timeout_secs
+                    ))
+                })?
+                .map_err(|e| ServiceManagerError::Other(e.to_string()))
+        }
+    }
+}
+
+impl ServiceManager for ZinitServiceManager {
+    fn exists(&self, service_name: &str) -> Result<bool, ServiceManagerError> {
+        let status_res = self.status(service_name);
+        match status_res {
+            Ok(_) => Ok(true),
+            Err(ServiceManagerError::ServiceNotFound(_)) => Ok(false),
+            Err(e) => Err(e),
+        }
+    }
+
+    fn start(&self, config: &ServiceConfig) -> Result<(), ServiceManagerError> {
+        // Build the exec command with args
+        let mut exec_command = config.binary_path.clone();
+        if !config.args.is_empty() {
+            exec_command.push(' ');
+            exec_command.push_str(&config.args.join(" "));
+        }
+
+        // Create zinit-compatible service configuration
+        let mut service_config = json!({
+            "exec": exec_command,
+            "oneshot": !config.auto_restart,  // zinit uses oneshot, not restart
+            "env": config.environment,
+        });
+
+        // Add optional fields if present
+        if let Some(ref working_dir) = config.working_directory {
+            // Zinit doesn't support working_directory directly, so we need to modify the exec command
+            let cd_command = format!("cd {} && {}", working_dir, exec_command);
+            service_config["exec"] = json!(cd_command);
+        }
+
+        let client = Arc::clone(&self.client);
+        let service_name = config.name.clone();
+        self.execute_async(
+            async move { client.create_service(&service_name, service_config).await },
+        )
+        .map_err(|e| ServiceManagerError::StartFailed(config.name.clone(), e.to_string()))?;
+
+        self.start_existing(&config.name)
+    }
+
+    fn start_existing(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let client = Arc::clone(&self.client);
+        let service_name_owned = service_name.to_string();
+        let service_name_for_error = service_name.to_string();
+        self.execute_async(async move { client.start(&service_name_owned).await })
+            .map_err(|e| ServiceManagerError::StartFailed(service_name_for_error, e.to_string()))
+    }
+
+    fn start_and_confirm(
+        &self,
+        config: &ServiceConfig,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // Start the service first
+        self.start(config)?;
+
+        // Wait for confirmation with timeout using the shared runtime
+        self.execute_async_with_timeout(
+            async move {
+                let start_time = std::time::Instant::now();
+                let timeout_duration = Duration::from_secs(timeout_secs);
+
+                while start_time.elapsed() < timeout_duration {
+                    // We need to call status in a blocking way from within the async context
+                    // For now, we'll use a simple polling approach
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                }
+
+                // Return a timeout error that will be handled by execute_async_with_timeout
+                // Use a generic error since we don't know the exact ZinitError variants
+                Err(ZinitError::from(std::io::Error::new(
+                    std::io::ErrorKind::TimedOut,
+                    "Timeout waiting for service confirmation",
+                )))
+            },
+            timeout_secs,
+        )?;
+
+        // Check final status
+        match self.status(&config.name)? {
+            ServiceStatus::Running => Ok(()),
+            ServiceStatus::Failed => Err(ServiceManagerError::StartFailed(
+                config.name.clone(),
+                "Service failed to start".to_string(),
+            )),
+            _ => Err(ServiceManagerError::StartFailed(
+                config.name.clone(),
+                format!("Service did not start within {} seconds", timeout_secs),
+            )),
+        }
+    }
+
+    fn start_existing_and_confirm(
+        &self,
+        service_name: &str,
+        timeout_secs: u64,
+    ) -> Result<(), ServiceManagerError> {
+        // Start the existing service first
+        self.start_existing(service_name)?;
+
+        // Wait for confirmation with timeout using the shared runtime
+        self.execute_async_with_timeout(
+            async move {
+                let start_time = std::time::Instant::now();
+                let timeout_duration = Duration::from_secs(timeout_secs);
+
+                while start_time.elapsed() < timeout_duration {
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                }
+
+                // Return a timeout error that will be handled by execute_async_with_timeout
+                // Use a generic error since we don't know the exact ZinitError variants
+                Err(ZinitError::from(std::io::Error::new(
+                    std::io::ErrorKind::TimedOut,
+                    "Timeout waiting for service confirmation",
+                )))
+            },
+            timeout_secs,
+        )?;
+
+        // Check final status
+        match self.status(service_name)? {
+            ServiceStatus::Running => Ok(()),
+            ServiceStatus::Failed => Err(ServiceManagerError::StartFailed(
+                service_name.to_string(),
+                "Service failed to start".to_string(),
+            )),
+            _ => Err(ServiceManagerError::StartFailed(
+                service_name.to_string(),
+                format!("Service did not start within {} seconds", timeout_secs),
+            )),
+        }
+    }
+
+    fn stop(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let client = Arc::clone(&self.client);
+        let service_name_owned = service_name.to_string();
+        let service_name_for_error = service_name.to_string();
+        self.execute_async(async move { client.stop(&service_name_owned).await })
+            .map_err(|e| ServiceManagerError::StopFailed(service_name_for_error, e.to_string()))
+    }
+
+    fn restart(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        let client = Arc::clone(&self.client);
+        let service_name_owned = service_name.to_string();
+        let service_name_for_error = service_name.to_string();
+        self.execute_async(async move { client.restart(&service_name_owned).await })
+            .map_err(|e| ServiceManagerError::RestartFailed(service_name_for_error, e.to_string()))
+    }
+
+    fn status(&self, service_name: &str) -> Result<ServiceStatus, ServiceManagerError> {
+        let client = Arc::clone(&self.client);
+        let service_name_owned = service_name.to_string();
+        let service_name_for_error = service_name.to_string();
+        let status: ZinitServiceStatus = self
+            .execute_async(async move { client.status(&service_name_owned).await })
+            .map_err(|e| {
+                // Check if this is a "service not found" error
+                if e.to_string().contains("not found") || e.to_string().contains("does not exist") {
+                    ServiceManagerError::ServiceNotFound(service_name_for_error)
+                } else {
+                    ServiceManagerError::Other(e.to_string())
+                }
+            })?;
+
+        // ServiceStatus is a struct with fields, not an enum
+        // We need to check the state field to determine the status
+        // Convert ServiceState to string and match on that
+        let state_str = format!("{:?}", status.state).to_lowercase();
+        let service_status = match state_str.as_str() {
+            s if s.contains("running") => crate::ServiceStatus::Running,
+            s if s.contains("stopped") => crate::ServiceStatus::Stopped,
+            s if s.contains("failed") => crate::ServiceStatus::Failed,
+            _ => crate::ServiceStatus::Unknown,
+        };
+        Ok(service_status)
+    }
+
+    fn logs(
+        &self,
+        service_name: &str,
+        _lines: Option<usize>,
+    ) -> Result<String, ServiceManagerError> {
+        // The logs method takes (follow: bool, filter: Option<impl AsRef<str>>)
+        let client = Arc::clone(&self.client);
+        let service_name_owned = service_name.to_string();
+        let logs = self
+            .execute_async(async move {
+                use futures::StreamExt;
+                use tokio::time::{timeout, Duration};
+
+                let mut log_stream = client
+                    .logs(false, Some(service_name_owned.as_str()))
+                    .await?;
+                let mut logs = Vec::new();
+
+                // Collect logs from the stream with a reasonable limit
+                let mut count = 0;
+                const MAX_LOGS: usize = 100;
+                const LOG_TIMEOUT: Duration = Duration::from_secs(5);
+
+                // Use timeout to prevent hanging
+                let result = timeout(LOG_TIMEOUT, async {
+                    while let Some(log_result) = log_stream.next().await {
+                        match log_result {
+                            Ok(log_entry) => {
+                                logs.push(format!("{:?}", log_entry));
+                                count += 1;
+                                if count >= MAX_LOGS {
+                                    break;
+                                }
+                            }
+                            Err(_) => break,
+                        }
+                    }
+                })
+                .await;
+
+                // Handle timeout - this is not an error, just means no more logs available
+                if result.is_err() {
+                    log::debug!(
+                        "Log reading timed out after {} seconds, returning {} logs",
+                        LOG_TIMEOUT.as_secs(),
+                        logs.len()
+                    );
+                }
+
+                Ok::<Vec<String>, ZinitError>(logs)
+            })
+            .map_err(|e| {
+                ServiceManagerError::LogsFailed(service_name.to_string(), e.to_string())
+            })?;
+        Ok(logs.join("\n"))
+    }
+
+    fn list(&self) -> Result<Vec<String>, ServiceManagerError> {
+        let client = Arc::clone(&self.client);
+        let services = self
+            .execute_async(async move { client.list().await })
+            .map_err(|e| ServiceManagerError::Other(e.to_string()))?;
+        Ok(services.keys().cloned().collect())
+    }
+
+    fn remove(&self, service_name: &str) -> Result<(), ServiceManagerError> {
+        // Try to stop the service first, but don't fail if it's already stopped or doesn't exist
+        if let Err(e) = self.stop(service_name) {
+            // Log the error but continue with removal
+            log::warn!(
+                "Failed to stop service '{}' before removal: {}",
+                service_name,
+                e
+            );
+        }
+
+        let client = Arc::clone(&self.client);
+        let service_name = service_name.to_string();
+        self.execute_async(async move { client.delete_service(&service_name).await })
+            .map_err(|e| ServiceManagerError::Other(e.to_string()))
+    }
+}

_archive/service_manager/tests/factory_tests.rs

@@ -0,0 +1,243 @@
+use sal_service_manager::{create_service_manager, ServiceConfig, ServiceManager};
+use std::collections::HashMap;
+
+#[test]
+fn test_create_service_manager() {
+    // Test that the factory function creates the appropriate service manager for the platform
+    let manager = create_service_manager().expect("Failed to create service manager");
+
+    // Test basic functionality - should be able to call methods without panicking
+    let list_result = manager.list();
+
+    // The result might be an error (if no service system is available), but it shouldn't panic
+    match list_result {
+        Ok(services) => {
+            println!(
+                "✓ Service manager created successfully, found {} services",
+                services.len()
+            );
+        }
+        Err(e) => {
+            println!("✓ Service manager created, but got expected error: {}", e);
+            // This is expected on systems without the appropriate service manager
+        }
+    }
+}
+
+#[test]
+fn test_service_config_creation() {
+    // Test creating various service configurations
+    let basic_config = ServiceConfig {
+        name: "test-service".to_string(),
+        binary_path: "/usr/bin/echo".to_string(),
+        args: vec!["hello".to_string(), "world".to_string()],
+        working_directory: None,
+        environment: HashMap::new(),
+        auto_restart: false,
+    };
+
+    assert_eq!(basic_config.name, "test-service");
+    assert_eq!(basic_config.binary_path, "/usr/bin/echo");
+    assert_eq!(basic_config.args.len(), 2);
+    assert_eq!(basic_config.args[0], "hello");
+    assert_eq!(basic_config.args[1], "world");
+    assert!(basic_config.working_directory.is_none());
+    assert!(basic_config.environment.is_empty());
+    assert!(!basic_config.auto_restart);
+
+    println!("✓ Basic service config created successfully");
+
+    // Test config with environment variables
+    let mut env = HashMap::new();
+    env.insert("PATH".to_string(), "/usr/bin:/bin".to_string());
+    env.insert("HOME".to_string(), "/tmp".to_string());
+
+    let env_config = ServiceConfig {
+        name: "env-service".to_string(),
+        binary_path: "/usr/bin/env".to_string(),
+        args: vec![],
+        working_directory: Some("/tmp".to_string()),
+        environment: env.clone(),
+        auto_restart: true,
+    };
+
+    assert_eq!(env_config.name, "env-service");
+    assert_eq!(env_config.binary_path, "/usr/bin/env");
+    assert!(env_config.args.is_empty());
+    assert_eq!(env_config.working_directory, Some("/tmp".to_string()));
+    assert_eq!(env_config.environment.len(), 2);
+    assert_eq!(
+        env_config.environment.get("PATH"),
+        Some(&"/usr/bin:/bin".to_string())
+    );
+    assert_eq!(
+        env_config.environment.get("HOME"),
+        Some(&"/tmp".to_string())
+    );
+    assert!(env_config.auto_restart);
+
+    println!("✓ Environment service config created successfully");
+}
+
+#[test]
+fn test_service_config_clone() {
+    // Test that ServiceConfig can be cloned
+    let original_config = ServiceConfig {
+        name: "original".to_string(),
+        binary_path: "/bin/sh".to_string(),
+        args: vec!["-c".to_string(), "echo test".to_string()],
+        working_directory: Some("/home".to_string()),
+        environment: {
+            let mut env = HashMap::new();
+            env.insert("TEST".to_string(), "value".to_string());
+            env
+        },
+        auto_restart: true,
+    };
+
+    let cloned_config = original_config.clone();
+
+    assert_eq!(original_config.name, cloned_config.name);
+    assert_eq!(original_config.binary_path, cloned_config.binary_path);
+    assert_eq!(original_config.args, cloned_config.args);
+    assert_eq!(
+        original_config.working_directory,
+        cloned_config.working_directory
+    );
+    assert_eq!(original_config.environment, cloned_config.environment);
+    assert_eq!(original_config.auto_restart, cloned_config.auto_restart);
+
+    println!("✓ Service config cloning works correctly");
+}
+
+#[cfg(target_os = "macos")]
+#[test]
+fn test_macos_service_manager() {
+    use sal_service_manager::LaunchctlServiceManager;
+
+    // Test creating macOS-specific service manager
+    let manager = LaunchctlServiceManager::new();
+
+    // Test basic functionality
+    let list_result = manager.list();
+    match list_result {
+        Ok(services) => {
+            println!(
+                "✓ macOS LaunchctlServiceManager created successfully, found {} services",
+                services.len()
+            );
+        }
+        Err(e) => {
+            println!(
+                "✓ macOS LaunchctlServiceManager created, but got expected error: {}",
+                e
+            );
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_linux_service_manager() {
+    use sal_service_manager::SystemdServiceManager;
+
+    // Test creating Linux-specific service manager
+    let manager = SystemdServiceManager::new();
+
+    // Test basic functionality
+    let list_result = manager.list();
+    match list_result {
+        Ok(services) => {
+            println!(
+                "✓ Linux SystemdServiceManager created successfully, found {} services",
+                services.len()
+            );
+        }
+        Err(e) => {
+            println!(
+                "✓ Linux SystemdServiceManager created, but got expected error: {}",
+                e
+            );
+        }
+    }
+}
+
+#[test]
+fn test_service_status_debug() {
+    use sal_service_manager::ServiceStatus;
+
+    // Test that ServiceStatus can be debugged and cloned
+    let statuses = vec![
+        ServiceStatus::Running,
+        ServiceStatus::Stopped,
+        ServiceStatus::Failed,
+        ServiceStatus::Unknown,
+    ];
+
+    for status in &statuses {
+        let cloned = status.clone();
+        let debug_str = format!("{:?}", status);
+
+        assert!(!debug_str.is_empty());
+        assert_eq!(status, &cloned);
+
+        println!(
+            "✓ ServiceStatus::{:?} debug and clone work correctly",
+            status
+        );
+    }
+}
+
+#[test]
+fn test_service_manager_error_debug() {
+    use sal_service_manager::ServiceManagerError;
+
+    // Test that ServiceManagerError can be debugged and displayed
+    let errors = vec![
+        ServiceManagerError::ServiceNotFound("test".to_string()),
+        ServiceManagerError::ServiceAlreadyExists("test".to_string()),
+        ServiceManagerError::StartFailed("test".to_string(), "reason".to_string()),
+        ServiceManagerError::StopFailed("test".to_string(), "reason".to_string()),
+        ServiceManagerError::RestartFailed("test".to_string(), "reason".to_string()),
+        ServiceManagerError::LogsFailed("test".to_string(), "reason".to_string()),
+        ServiceManagerError::Other("generic error".to_string()),
+    ];
+
+    for error in &errors {
+        let debug_str = format!("{:?}", error);
+        let display_str = format!("{}", error);
+
+        assert!(!debug_str.is_empty());
+        assert!(!display_str.is_empty());
+
+        println!("✓ Error debug: {:?}", error);
+        println!("✓ Error display: {}", error);
+    }
+}
+
+#[test]
+fn test_service_manager_trait_object() {
+    // Test that we can use ServiceManager as a trait object
+    let manager: Box<dyn ServiceManager> =
+        create_service_manager().expect("Failed to create service manager");
+
+    // Test that we can call methods through the trait object
+    let list_result = manager.list();
+
+    match list_result {
+        Ok(services) => {
+            println!("✓ Trait object works, found {} services", services.len());
+        }
+        Err(e) => {
+            println!("✓ Trait object works, got expected error: {}", e);
+        }
+    }
+
+    // Test exists method
+    let exists_result = manager.exists("non-existent-service");
+    match exists_result {
+        Ok(false) => println!("✓ Trait object exists method works correctly"),
+        Ok(true) => println!("⚠ Unexpectedly found non-existent service"),
+        Err(_) => println!("✓ Trait object exists method works (with error)"),
+    }
+}

_archive/service_manager/tests/rhai/service_lifecycle.rhai

@@ -0,0 +1,177 @@
+// Service lifecycle management test script
+// This script tests REAL complete service lifecycle scenarios
+
+print("=== Service Lifecycle Management Test ===");
+
+// Create service manager
+let manager = create_service_manager();
+print("✓ Service manager created");
+
+// Test configuration - real services for testing
+let test_services = [
+    #{
+        name: "lifecycle-test-1",
+        binary_path: "/bin/echo",
+        args: ["Lifecycle test 1"],
+        working_directory: "/tmp",
+        environment: #{},
+        auto_restart: false
+    },
+    #{
+        name: "lifecycle-test-2",
+        binary_path: "/bin/echo",
+        args: ["Lifecycle test 2"],
+        working_directory: "/tmp",
+        environment: #{ "TEST_VAR": "test_value" },
+        auto_restart: false
+    }
+];
+
+let total_tests = 0;
+let passed_tests = 0;
+
+// Test 1: Service Creation and Start
+print("\n1. Testing service creation and start...");
+for service_config in test_services {
+    print(`\nStarting service: ${service_config.name}`);
+    try {
+        start(manager, service_config);
+        print(`  ✓ Service ${service_config.name} started successfully`);
+        passed_tests += 1;
+    } catch(e) {
+        print(`  ✗ Service ${service_config.name} start failed: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test 2: Service Existence Check
+print("\n2. Testing service existence checks...");
+for service_config in test_services {
+    print(`\nChecking existence of: ${service_config.name}`);
+    try {
+        let service_exists = exists(manager, service_config.name);
+        if service_exists {
+            print(`  ✓ Service ${service_config.name} exists: ${service_exists}`);
+            passed_tests += 1;
+        } else {
+            print(`  ✗ Service ${service_config.name} doesn't exist after start`);
+        }
+    } catch(e) {
+        print(`  ✗ Existence check failed for ${service_config.name}: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test 3: Status Check
+print("\n3. Testing status checks...");
+for service_config in test_services {
+    print(`\nChecking status of: ${service_config.name}`);
+    try {
+        let service_status = status(manager, service_config.name);
+        print(`  ✓ Service ${service_config.name} status: ${service_status}`);
+        passed_tests += 1;
+    } catch(e) {
+        print(`  ✗ Status check failed for ${service_config.name}: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test 4: Service List Check
+print("\n4. Testing service list...");
+try {
+    let services = list(manager);
+    print(`  ✓ Service list retrieved (${services.len()} services)`);
+
+    // Check if our test services are in the list
+    for service_config in test_services {
+        let found = false;
+        for service in services {
+            if service.contains(service_config.name) {
+                found = true;
+                print(`    ✓ Found ${service_config.name} in list`);
+                break;
+            }
+        }
+        if !found {
+            print(`    ⚠ ${service_config.name} not found in service list`);
+        }
+    }
+    passed_tests += 1;
+} catch(e) {
+    print(`  ✗ Service list failed: ${e}`);
+}
+total_tests += 1;
+
+// Test 5: Service Stop
+print("\n5. Testing service stop...");
+for service_config in test_services {
+    print(`\nStopping service: ${service_config.name}`);
+    try {
+        stop(manager, service_config.name);
+        print(`  ✓ Service ${service_config.name} stopped successfully`);
+        passed_tests += 1;
+    } catch(e) {
+        print(`  ✗ Service ${service_config.name} stop failed: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test 6: Service Removal
+print("\n6. Testing service removal...");
+for service_config in test_services {
+    print(`\nRemoving service: ${service_config.name}`);
+    try {
+        remove(manager, service_config.name);
+        print(`  ✓ Service ${service_config.name} removed successfully`);
+        passed_tests += 1;
+    } catch(e) {
+        print(`  ✗ Service ${service_config.name} removal failed: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test 7: Cleanup Verification
+print("\n7. Testing cleanup verification...");
+for service_config in test_services {
+    print(`\nVerifying removal of: ${service_config.name}`);
+    try {
+        let exists_after_remove = exists(manager, service_config.name);
+        if !exists_after_remove {
+            print(`  ✓ Service ${service_config.name} correctly doesn't exist after removal`);
+            passed_tests += 1;
+        } else {
+            print(`  ✗ Service ${service_config.name} still exists after removal`);
+        }
+    } catch(e) {
+        print(`  ✗ Cleanup verification failed for ${service_config.name}: ${e}`);
+    }
+    total_tests += 1;
+}
+
+// Test Summary
+print("\n=== Lifecycle Test Summary ===");
+print(`Services tested: ${test_services.len()}`);
+print(`Total operations: ${total_tests}`);
+print(`Successful operations: ${passed_tests}`);
+print(`Failed operations: ${total_tests - passed_tests}`);
+print(`Success rate: ${(passed_tests * 100) / total_tests}%`);
+
+if passed_tests == total_tests {
+    print("\n🎉 All lifecycle tests passed!");
+    print("Service manager is working correctly across all scenarios.");
+} else {
+    print(`\n⚠ ${total_tests - passed_tests} test(s) failed`);
+    print("Some service manager operations need attention.");
+}
+
+print("\n=== Service Lifecycle Test Complete ===");
+
+// Return test results
+#{
+    summary: #{
+        total_tests: total_tests,
+        passed_tests: passed_tests,
+        success_rate: (passed_tests * 100) / total_tests,
+        services_tested: test_services.len()
+    }
+}

_archive/service_manager/tests/rhai/service_manager_basic.rhai

@@ -0,0 +1,218 @@
+// Basic service manager functionality test script
+// This script tests the REAL service manager through Rhai integration
+
+print("=== Service Manager Basic Functionality Test ===");
+
+// Test configuration
+let test_service_name = "rhai-test-service";
+let test_binary = "/bin/echo";
+let test_args = ["Hello from Rhai service manager test"];
+
+print(`Testing service: ${test_service_name}`);
+print(`Binary: ${test_binary}`);
+print(`Args: ${test_args}`);
+
+// Test results tracking
+let test_results = #{
+    creation: "NOT_RUN",
+    exists_before: "NOT_RUN",
+    start: "NOT_RUN",
+    exists_after: "NOT_RUN",
+    status: "NOT_RUN",
+    list: "NOT_RUN",
+    stop: "NOT_RUN",
+    remove: "NOT_RUN",
+    cleanup: "NOT_RUN"
+};
+
+let passed_tests = 0;
+let total_tests = 0;
+
+// Test 1: Service Manager Creation
+print("\n1. Testing service manager creation...");
+try {
+    let manager = create_service_manager();
+    print("✓ Service manager created successfully");
+    test_results["creation"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service manager creation failed: ${e}`);
+    test_results["creation"] = "FAIL";
+    total_tests += 1;
+    // Return early if we can't create the manager
+    return test_results;
+}
+
+// Create the service manager for all subsequent tests
+let manager = create_service_manager();
+
+// Test 2: Check if service exists before creation
+print("\n2. Testing service existence check (before creation)...");
+try {
+    let exists_before = exists(manager, test_service_name);
+    print(`✓ Service existence check: ${exists_before}`);
+
+    if !exists_before {
+        print("✓ Service correctly doesn't exist before creation");
+        test_results["exists_before"] = "PASS";
+        passed_tests += 1;
+    } else {
+        print("⚠ Service unexpectedly exists before creation");
+        test_results["exists_before"] = "WARN";
+    }
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service existence check failed: ${e}`);
+    test_results["exists_before"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 3: Start the service
+print("\n3. Testing service start...");
+try {
+    // Create a service configuration object
+    let service_config = #{
+        name: test_service_name,
+        binary_path: test_binary,
+        args: test_args,
+        working_directory: "/tmp",
+        environment: #{},
+        auto_restart: false
+    };
+
+    start(manager, service_config);
+    print("✓ Service started successfully");
+    test_results["start"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service start failed: ${e}`);
+    test_results["start"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 4: Check if service exists after creation
+print("\n4. Testing service existence check (after creation)...");
+try {
+    let exists_after = exists(manager, test_service_name);
+    print(`✓ Service existence check: ${exists_after}`);
+
+    if exists_after {
+        print("✓ Service correctly exists after creation");
+        test_results["exists_after"] = "PASS";
+        passed_tests += 1;
+    } else {
+        print("✗ Service doesn't exist after creation");
+        test_results["exists_after"] = "FAIL";
+    }
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service existence check failed: ${e}`);
+    test_results["exists_after"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 5: Check service status
+print("\n5. Testing service status...");
+try {
+    let service_status = status(manager, test_service_name);
+    print(`✓ Service status: ${service_status}`);
+    test_results["status"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service status check failed: ${e}`);
+    test_results["status"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 6: List services
+print("\n6. Testing service list...");
+try {
+    let services = list(manager);
+    print("✓ Service list retrieved");
+
+    // Skip service search due to Rhai type constraints with Vec iteration
+    print("  ⚠️  Skipping service search due to Rhai type constraints");
+
+    test_results["list"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service list failed: ${e}`);
+    test_results["list"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 7: Stop the service
+print("\n7. Testing service stop...");
+try {
+    stop(manager, test_service_name);
+    print(`✓ Service stopped: ${test_service_name}`);
+    test_results["stop"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service stop failed: ${e}`);
+    test_results["stop"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 8: Remove the service
+print("\n8. Testing service remove...");
+try {
+    remove(manager, test_service_name);
+    print(`✓ Service removed: ${test_service_name}`);
+    test_results["remove"] = "PASS";
+    passed_tests += 1;
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Service remove failed: ${e}`);
+    test_results["remove"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test 9: Verify cleanup
+print("\n9. Testing cleanup verification...");
+try {
+    let exists_after_remove = exists(manager, test_service_name);
+    if !exists_after_remove {
+        print("✓ Service correctly doesn't exist after removal");
+        test_results["cleanup"] = "PASS";
+        passed_tests += 1;
+    } else {
+        print("✗ Service still exists after removal");
+        test_results["cleanup"] = "FAIL";
+    }
+    total_tests += 1;
+} catch(e) {
+    print(`✗ Cleanup verification failed: ${e}`);
+    test_results["cleanup"] = "FAIL";
+    total_tests += 1;
+}
+
+// Test Summary
+print("\n=== Test Summary ===");
+print(`Total tests: ${total_tests}`);
+print(`Passed: ${passed_tests}`);
+print(`Failed: ${total_tests - passed_tests}`);
+print(`Success rate: ${(passed_tests * 100) / total_tests}%`);
+
+print("\nDetailed Results:");
+for test_name in test_results.keys() {
+    let result = test_results[test_name];
+    let status_icon = if result == "PASS" { "✓" } else if result == "FAIL" { "✗" } else { "⚠" };
+    print(`  ${status_icon} ${test_name}: ${result}`);
+}
+
+if passed_tests == total_tests {
+    print("\n🎉 All tests passed!");
+} else {
+    print(`\n⚠ ${total_tests - passed_tests} test(s) failed`);
+}
+
+print("\n=== Service Manager Basic Test Complete ===");
+
+// Return test results for potential use by calling code
+test_results

_archive/service_manager/tests/rhai_integration_tests.rs

@@ -0,0 +1,252 @@
+use rhai::{Engine, EvalAltResult};
+use std::fs;
+use std::path::Path;
+
+/// Helper function to create a Rhai engine for service manager testing
+fn create_service_manager_engine() -> Result<Engine, Box<EvalAltResult>> {
+    #[cfg(feature = "rhai")]
+    {
+        let mut engine = Engine::new();
+        // Register the service manager module for real testing
+        sal_service_manager::rhai::register_service_manager_module(&mut engine)?;
+        Ok(engine)
+    }
+    #[cfg(not(feature = "rhai"))]
+    {
+        Ok(Engine::new())
+    }
+}
+
+/// Helper function to run a Rhai script file
+fn run_rhai_script(script_path: &str) -> Result<rhai::Dynamic, Box<EvalAltResult>> {
+    let engine = create_service_manager_engine()?;
+
+    // Read the script file
+    let script_content = fs::read_to_string(script_path)
+        .map_err(|e| format!("Failed to read script file {}: {}", script_path, e))?;
+
+    // Execute the script
+    engine.eval::<rhai::Dynamic>(&script_content)
+}
+
+#[test]
+fn test_rhai_service_manager_basic() {
+    let script_path = "tests/rhai/service_manager_basic.rhai";
+
+    if !Path::new(script_path).exists() {
+        println!("⚠ Skipping test: Rhai script not found at {}", script_path);
+        return;
+    }
+
+    println!("Running Rhai service manager basic test...");
+
+    match run_rhai_script(script_path) {
+        Ok(result) => {
+            println!("✓ Rhai basic test completed successfully");
+
+            // Try to extract test results if the script returns them
+            if let Some(map) = result.try_cast::<rhai::Map>() {
+                println!("Test results received from Rhai script:");
+                for (key, value) in map.iter() {
+                    println!("  {}: {:?}", key, value);
+                }
+
+                // Check if all tests passed
+                let all_passed = map.values().all(|v| {
+                    if let Some(s) = v.clone().try_cast::<String>() {
+                        s == "PASS"
+                    } else {
+                        false
+                    }
+                });
+
+                if all_passed {
+                    println!("✓ All Rhai tests reported as PASS");
+                } else {
+                    println!("⚠ Some Rhai tests did not pass");
+                }
+            }
+        }
+        Err(e) => {
+            println!("✗ Rhai basic test failed: {}", e);
+            assert!(false, "Rhai script execution failed: {}", e);
+        }
+    }
+}
+
+#[test]
+fn test_rhai_service_lifecycle() {
+    let script_path = "tests/rhai/service_lifecycle.rhai";
+
+    if !Path::new(script_path).exists() {
+        println!("⚠ Skipping test: Rhai script not found at {}", script_path);
+        return;
+    }
+
+    println!("Running Rhai service lifecycle test...");
+
+    match run_rhai_script(script_path) {
+        Ok(result) => {
+            println!("✓ Rhai lifecycle test completed successfully");
+
+            // Try to extract test results if the script returns them
+            if let Some(map) = result.try_cast::<rhai::Map>() {
+                println!("Lifecycle test results received from Rhai script:");
+
+                // Extract summary if available
+                if let Some(summary) = map.get("summary") {
+                    if let Some(summary_map) = summary.clone().try_cast::<rhai::Map>() {
+                        println!("Summary:");
+                        for (key, value) in summary_map.iter() {
+                            println!("  {}: {:?}", key, value);
+                        }
+                    }
+                }
+
+                // Extract performance metrics if available
+                if let Some(performance) = map.get("performance") {
+                    if let Some(perf_map) = performance.clone().try_cast::<rhai::Map>() {
+                        println!("Performance:");
+                        for (key, value) in perf_map.iter() {
+                            println!("  {}: {:?}", key, value);
+                        }
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            println!("✗ Rhai lifecycle test failed: {}", e);
+            assert!(false, "Rhai script execution failed: {}", e);
+        }
+    }
+}
+
+#[test]
+fn test_rhai_engine_functionality() {
+    println!("Testing basic Rhai engine functionality...");
+
+    let engine = create_service_manager_engine().expect("Failed to create Rhai engine");
+
+    // Test basic Rhai functionality
+    let test_script = r#"
+        let test_results = #{
+            basic_math: 2 + 2 == 4,
+            string_ops: "hello".len() == 5,
+            array_ops: [1, 2, 3].len() == 3,
+            map_ops: #{ a: 1, b: 2 }.len() == 2
+        };
+        
+        let all_passed = true;
+        for result in test_results.values() {
+            if !result {
+                all_passed = false;
+                break;
+            }
+        }
+        
+        #{
+            results: test_results,
+            all_passed: all_passed
+        }
+    "#;
+
+    match engine.eval::<rhai::Dynamic>(test_script) {
+        Ok(result) => {
+            if let Some(map) = result.try_cast::<rhai::Map>() {
+                if let Some(all_passed) = map.get("all_passed") {
+                    if let Some(passed) = all_passed.clone().try_cast::<bool>() {
+                        if passed {
+                            println!("✓ All basic Rhai functionality tests passed");
+                        } else {
+                            println!("✗ Some basic Rhai functionality tests failed");
+                            assert!(false, "Basic Rhai tests failed");
+                        }
+                    }
+                }
+
+                if let Some(results) = map.get("results") {
+                    if let Some(results_map) = results.clone().try_cast::<rhai::Map>() {
+                        println!("Detailed results:");
+                        for (test_name, result) in results_map.iter() {
+                            let status = if let Some(passed) = result.clone().try_cast::<bool>() {
+                                if passed {
+                                    "✓"
+                                } else {
+                                    "✗"
+                                }
+                            } else {
+                                "?"
+                            };
+                            println!("  {} {}: {:?}", status, test_name, result);
+                        }
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            println!("✗ Basic Rhai functionality test failed: {}", e);
+            assert!(false, "Basic Rhai test failed: {}", e);
+        }
+    }
+}
+
+#[test]
+fn test_rhai_script_error_handling() {
+    println!("Testing Rhai error handling...");
+
+    let engine = create_service_manager_engine().expect("Failed to create Rhai engine");
+
+    // Test script with intentional error
+    let error_script = r#"
+        let result = "test";
+        result.non_existent_method(); // This should cause an error
+    "#;
+
+    match engine.eval::<rhai::Dynamic>(error_script) {
+        Ok(_) => {
+            println!("⚠ Expected error but script succeeded");
+            assert!(
+                false,
+                "Error handling test failed - expected error but got success"
+            );
+        }
+        Err(e) => {
+            println!("✓ Error correctly caught: {}", e);
+            // Verify it's the expected type of error
+            assert!(e.to_string().contains("method") || e.to_string().contains("function"));
+        }
+    }
+}
+
+#[test]
+fn test_rhai_script_files_exist() {
+    println!("Checking that Rhai test scripts exist...");
+
+    let script_files = [
+        "tests/rhai/service_manager_basic.rhai",
+        "tests/rhai/service_lifecycle.rhai",
+    ];
+
+    for script_file in &script_files {
+        if Path::new(script_file).exists() {
+            println!("✓ Found script: {}", script_file);
+
+            // Verify the file is readable and not empty
+            match fs::read_to_string(script_file) {
+                Ok(content) => {
+                    if content.trim().is_empty() {
+                        assert!(false, "Script file {} is empty", script_file);
+                    }
+                    println!("  Content length: {} characters", content.len());
+                }
+                Err(e) => {
+                    assert!(false, "Failed to read script file {}: {}", script_file, e);
+                }
+            }
+        } else {
+            assert!(false, "Required script file not found: {}", script_file);
+        }
+    }
+
+    println!("✓ All required Rhai script files exist and are readable");
+}

_archive/service_manager/tests/zinit_integration_tests.rs

@@ -0,0 +1,317 @@
+use sal_service_manager::{
+    ServiceConfig, ServiceManager, ServiceManagerError, ServiceStatus, ZinitServiceManager,
+};
+use std::collections::HashMap;
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// Helper function to find an available Zinit socket path
+async fn get_available_socket_path() -> Option<String> {
+    let socket_paths = [
+        "/var/run/zinit.sock",
+        "/tmp/zinit.sock",
+        "/run/zinit.sock",
+        "./zinit.sock",
+    ];
+
+    for path in &socket_paths {
+        // Try to create a ZinitServiceManager to test connectivity
+        if let Ok(manager) = ZinitServiceManager::new(path) {
+            // Test if we can list services (basic connectivity test)
+            if manager.list().is_ok() {
+                println!("✓ Found working Zinit socket at: {}", path);
+                return Some(path.to_string());
+            }
+        }
+    }
+
+    None
+}
+
+/// Helper function to clean up test services
+async fn cleanup_test_service(manager: &dyn ServiceManager, service_name: &str) {
+    let _ = manager.stop(service_name);
+    let _ = manager.remove(service_name);
+}
+
+#[tokio::test]
+async fn test_zinit_service_manager_creation() {
+    if let Some(socket_path) = get_available_socket_path().await {
+        let manager = ZinitServiceManager::new(&socket_path);
+        assert!(
+            manager.is_ok(),
+            "Should be able to create ZinitServiceManager"
+        );
+
+        let manager = manager.unwrap();
+
+        // Test basic connectivity by listing services
+        let list_result = manager.list();
+        assert!(list_result.is_ok(), "Should be able to list services");
+
+        println!("✓ ZinitServiceManager created successfully");
+    } else {
+        println!("⚠ Skipping test_zinit_service_manager_creation: No Zinit socket available");
+    }
+}
+
+#[tokio::test]
+async fn test_service_lifecycle() {
+    if let Some(socket_path) = get_available_socket_path().await {
+        let manager = ZinitServiceManager::new(&socket_path).expect("Failed to create manager");
+        let service_name = "test-lifecycle-service";
+
+        // Clean up any existing service first
+        cleanup_test_service(&manager, service_name).await;
+
+        let config = ServiceConfig {
+            name: service_name.to_string(),
+            binary_path: "echo".to_string(),
+            args: vec!["Hello from lifecycle test".to_string()],
+            working_directory: Some("/tmp".to_string()),
+            environment: HashMap::new(),
+            auto_restart: false,
+        };
+
+        // Test service creation and start
+        println!("Testing service creation and start...");
+        let start_result = manager.start(&config);
+        match start_result {
+            Ok(_) => {
+                println!("✓ Service started successfully");
+
+                // Wait a bit for the service to run
+                sleep(Duration::from_millis(500)).await;
+
+                // Test service exists
+                let exists = manager.exists(service_name);
+                assert!(exists.is_ok(), "Should be able to check if service exists");
+
+                if let Ok(true) = exists {
+                    println!("✓ Service exists check passed");
+
+                    // Test service status
+                    let status_result = manager.status(service_name);
+                    match status_result {
+                        Ok(status) => {
+                            println!("✓ Service status: {:?}", status);
+                            assert!(
+                                matches!(status, ServiceStatus::Running | ServiceStatus::Stopped),
+                                "Service should be running or stopped (for oneshot)"
+                            );
+                        }
+                        Err(e) => println!("⚠ Status check failed: {}", e),
+                    }
+
+                    // Test service logs
+                    let logs_result = manager.logs(service_name, None);
+                    match logs_result {
+                        Ok(logs) => {
+                            println!("✓ Retrieved logs: {}", logs.len());
+                            // For echo command, we should have some output
+                            assert!(
+                                !logs.is_empty() || logs.contains("Hello"),
+                                "Should have log output"
+                            );
+                        }
+                        Err(e) => println!("⚠ Logs retrieval failed: {}", e),
+                    }
+
+                    // Test service list
+                    let list_result = manager.list();
+                    match list_result {
+                        Ok(services) => {
+                            println!("✓ Listed {} services", services.len());
+                            assert!(
+                                services.contains(&service_name.to_string()),
+                                "Service should appear in list"
+                            );
+                        }
+                        Err(e) => println!("⚠ List services failed: {}", e),
+                    }
+                }
+
+                // Test service stop
+                println!("Testing service stop...");
+                let stop_result = manager.stop(service_name);
+                match stop_result {
+                    Ok(_) => println!("✓ Service stopped successfully"),
+                    Err(e) => println!("⚠ Stop failed: {}", e),
+                }
+
+                // Test service removal
+                println!("Testing service removal...");
+                let remove_result = manager.remove(service_name);
+                match remove_result {
+                    Ok(_) => println!("✓ Service removed successfully"),
+                    Err(e) => println!("⚠ Remove failed: {}", e),
+                }
+            }
+            Err(e) => {
+                println!("⚠ Service creation/start failed: {}", e);
+                // This might be expected if zinit doesn't allow service creation
+            }
+        }
+
+        // Final cleanup
+        cleanup_test_service(&manager, service_name).await;
+    } else {
+        println!("⚠ Skipping test_service_lifecycle: No Zinit socket available");
+    }
+}
+
+#[tokio::test]
+async fn test_service_start_and_confirm() {
+    if let Some(socket_path) = get_available_socket_path().await {
+        let manager = ZinitServiceManager::new(&socket_path).expect("Failed to create manager");
+        let service_name = "test-start-confirm-service";
+
+        // Clean up any existing service first
+        cleanup_test_service(&manager, service_name).await;
+
+        let config = ServiceConfig {
+            name: service_name.to_string(),
+            binary_path: "sleep".to_string(),
+            args: vec!["5".to_string()], // Sleep for 5 seconds
+            working_directory: Some("/tmp".to_string()),
+            environment: HashMap::new(),
+            auto_restart: false,
+        };
+
+        // Test start_and_confirm with timeout
+        println!("Testing start_and_confirm with timeout...");
+        let start_result = manager.start_and_confirm(&config, 10);
+        match start_result {
+            Ok(_) => {
+                println!("✓ Service started and confirmed successfully");
+
+                // Verify it's actually running
+                let status = manager.status(service_name);
+                match status {
+                    Ok(ServiceStatus::Running) => println!("✓ Service confirmed running"),
+                    Ok(other_status) => {
+                        println!("⚠ Service in unexpected state: {:?}", other_status)
+                    }
+                    Err(e) => println!("⚠ Status check failed: {}", e),
+                }
+            }
+            Err(e) => {
+                println!("⚠ start_and_confirm failed: {}", e);
+            }
+        }
+
+        // Test start_existing_and_confirm
+        println!("Testing start_existing_and_confirm...");
+        let start_existing_result = manager.start_existing_and_confirm(service_name, 5);
+        match start_existing_result {
+            Ok(_) => println!("✓ start_existing_and_confirm succeeded"),
+            Err(e) => println!("⚠ start_existing_and_confirm failed: {}", e),
+        }
+
+        // Cleanup
+        cleanup_test_service(&manager, service_name).await;
+    } else {
+        println!("⚠ Skipping test_service_start_and_confirm: No Zinit socket available");
+    }
+}
+
+#[tokio::test]
+async fn test_service_restart() {
+    if let Some(socket_path) = get_available_socket_path().await {
+        let manager = ZinitServiceManager::new(&socket_path).expect("Failed to create manager");
+        let service_name = "test-restart-service";
+
+        // Clean up any existing service first
+        cleanup_test_service(&manager, service_name).await;
+
+        let config = ServiceConfig {
+            name: service_name.to_string(),
+            binary_path: "echo".to_string(),
+            args: vec!["Restart test".to_string()],
+            working_directory: Some("/tmp".to_string()),
+            environment: HashMap::new(),
+            auto_restart: true, // Enable auto-restart for this test
+        };
+
+        // Start the service first
+        let start_result = manager.start(&config);
+        if start_result.is_ok() {
+            // Wait for service to be established
+            sleep(Duration::from_millis(1000)).await;
+
+            // Test restart
+            println!("Testing service restart...");
+            let restart_result = manager.restart(service_name);
+            match restart_result {
+                Ok(_) => {
+                    println!("✓ Service restarted successfully");
+
+                    // Wait and check status
+                    sleep(Duration::from_millis(500)).await;
+
+                    let status_result = manager.status(service_name);
+                    match status_result {
+                        Ok(status) => {
+                            println!("✓ Service state after restart: {:?}", status);
+                        }
+                        Err(e) => println!("⚠ Status check after restart failed: {}", e),
+                    }
+                }
+                Err(e) => {
+                    println!("⚠ Restart failed: {}", e);
+                }
+            }
+        }
+
+        // Cleanup
+        cleanup_test_service(&manager, service_name).await;
+    } else {
+        println!("⚠ Skipping test_service_restart: No Zinit socket available");
+    }
+}
+
+#[tokio::test]
+async fn test_error_handling() {
+    if let Some(socket_path) = get_available_socket_path().await {
+        let manager = ZinitServiceManager::new(&socket_path).expect("Failed to create manager");
+
+        // Test operations on non-existent service
+        let non_existent_service = "non-existent-service-12345";
+
+        // Test status of non-existent service
+        let status_result = manager.status(non_existent_service);
+        match status_result {
+            Err(ServiceManagerError::ServiceNotFound(_)) => {
+                println!("✓ Correctly returned ServiceNotFound for non-existent service");
+            }
+            Err(other_error) => {
+                println!(
+                    "⚠ Got different error for non-existent service: {}",
+                    other_error
+                );
+            }
+            Ok(_) => {
+                println!("⚠ Unexpectedly found non-existent service");
+            }
+        }
+
+        // Test exists for non-existent service
+        let exists_result = manager.exists(non_existent_service);
+        match exists_result {
+            Ok(false) => println!("✓ Correctly reported non-existent service as not existing"),
+            Ok(true) => println!("⚠ Incorrectly reported non-existent service as existing"),
+            Err(e) => println!("⚠ Error checking existence: {}", e),
+        }
+
+        // Test stop of non-existent service
+        let stop_result = manager.stop(non_existent_service);
+        match stop_result {
+            Err(_) => println!("✓ Correctly failed to stop non-existent service"),
+            Ok(_) => println!("⚠ Unexpectedly succeeded in stopping non-existent service"),
+        }
+
+        println!("✓ Error handling tests completed");
+    } else {
+        println!("⚠ Skipping test_error_handling: No Zinit socket available");
+    }
+}

build_herodo.sh

@@ -6,10 +6,12 @@ cd "$(dirname "${BASH_SOURCE[0]}")"
 
 rm -f ./target/debug/herodo
 
-# Build the herodo project
+# Build the herodo project from the herodo package
-echo "Building herodo..."
+echo "Building herodo from herodo package..."
-cargo build --bin herodo
+cd herodo
-# cargo build --release --bin herodo
+cargo build
+# cargo build --release
+cd ..
 
 # Check if the build was successful
 if [ $? -ne 0 ]; then
@@ -20,8 +22,14 @@ fi
 # Echo a success message
 echo "Build successful!"
 
+if [ "$EUID" -eq 0 ]; then
+  echo "Running as root, copying to /usr/local/bin/"
+  cp target/debug/herodo /usr/local/bin/herodo
+else
+  echo "Running as non-root user, copying to ~/hero/bin/"
   mkdir -p ~/hero/bin/
   cp target/debug/herodo ~/hero/bin/herodo
+fi
 
 # Check if a script name was provided
 if [ $# -eq 1 ]; then

docs/docs/rhai/git_module_tests.md

@@ -16,13 +16,13 @@ Additionally, there's a runner script (`run_all_tests.rhai`) that executes all t
 To run all tests, execute the following command from the project root:
 
 ```bash
-herodo --path src/rhai_tests/git/run_all_tests.rhai
+herodo --path git/tests/rhai/run_all_tests.rhai
 ```
 
 To run individual test scripts:
 
 ```bash
-herodo --path src/rhai_tests/git/01_git_basic.rhai
+herodo --path git/tests/rhai/01_git_basic.rhai
 ```
 
 ## Test Details

docs/docs/rhai/mycelium_tutorial.md

@@ -0,0 +1,386 @@
+# Mycelium Tutorial for Rhai
+
+This tutorial explains how to use the Mycelium networking functionality in Rhai scripts. Mycelium is a peer-to-peer networking system that allows nodes to communicate with each other, and the Rhai bindings provide an easy way to interact with Mycelium from your scripts.
+
+## Introduction
+
+The Mycelium module for Rhai provides the following capabilities:
+
+- Getting node information
+- Managing peers (listing, adding, removing)
+- Viewing routing information
+- Sending and receiving messages between nodes
+
+This tutorial will walk you through using these features with example scripts.
+
+## Prerequisites
+
+Before using the Mycelium functionality in Rhai, you need:
+
+1. A running Mycelium node accessible via HTTP
+    > See https://github.com/threefoldtech/mycelium
+2. The Rhai runtime with Mycelium module enabled
+
+## Basic Mycelium Operations
+
+Let's start by exploring the basic operations available in Mycelium using the `mycelium_basic.rhai` example.
+
+### Getting Node Information
+
+To get information about your Mycelium node:
+
+```rhai
+// API URL for Mycelium
+let api_url = "http://localhost:8989";
+
+// Get node information
+print("Getting node information:");
+try {
+    let node_info = mycelium_get_node_info(api_url);
+    print(`Node subnet: ${node_info.nodeSubnet}`);
+    print(`Node public key: ${node_info.nodePubkey}`);
+} catch(err) {
+    print(`Error getting node info: ${err}`);
+}
+```
+
+This code:
+1. Sets the API URL for your Mycelium node
+2. Calls `mycelium_get_node_info()` to retrieve information about the node
+3. Prints the node's subnet and public key
+
+### Managing Peers
+
+#### Listing Peers
+
+To list all peers connected to your Mycelium node:
+
+```rhai
+// List all peers
+print("\nListing all peers:");
+try {
+    let peers = mycelium_list_peers(api_url);
+    
+    if peers.is_empty() {
+        print("No peers connected.");
+    } else {
+        for peer in peers {
+            print(`Peer Endpoint: ${peer.endpoint.proto}://${peer.endpoint.socketAddr}`);
+            print(`  Type: ${peer.type}`);
+            print(`  Connection State: ${peer.connectionState}`);
+            print(`  Bytes sent: ${peer.txBytes}`);
+            print(`  Bytes received: ${peer.rxBytes}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing peers: ${err}`);
+}
+```
+
+This code:
+1. Calls `mycelium_list_peers()` to get all connected peers
+2. Iterates through the peers and prints their details
+
+#### Adding a Peer
+
+To add a new peer to your Mycelium node:
+
+```rhai
+// Add a new peer
+print("\nAdding a new peer:");
+let new_peer_address = "tcp://65.21.231.58:9651";
+try {
+    let result = mycelium_add_peer(api_url, new_peer_address);
+    print(`Peer added: ${result.success}`);
+} catch(err) {
+    print(`Error adding peer: ${err}`);
+}
+```
+
+This code:
+1. Specifies a peer address to add
+2. Calls `mycelium_add_peer()` to add the peer to your node
+3. Prints whether the operation was successful
+
+#### Removing a Peer
+
+To remove a peer from your Mycelium node:
+
+```rhai
+// Remove a peer
+print("\nRemoving a peer:");
+let peer_id = "tcp://65.21.231.58:9651"; // This is the peer we added earlier
+try {
+    let result = mycelium_remove_peer(api_url, peer_id);
+    print(`Peer removed: ${result.success}`);
+} catch(err) {
+    print(`Error removing peer: ${err}`);
+}
+```
+
+This code:
+1. Specifies the peer ID to remove
+2. Calls `mycelium_remove_peer()` to remove the peer
+3. Prints whether the operation was successful
+
+### Viewing Routing Information
+
+#### Listing Selected Routes
+
+To list the selected routes in your Mycelium node:
+
+```rhai
+// List selected routes
+print("\nListing selected routes:");
+try {
+    let routes = mycelium_list_selected_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No selected routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing routes: ${err}`);
+}
+```
+
+This code:
+1. Calls `mycelium_list_selected_routes()` to get all selected routes
+2. Iterates through the routes and prints their details
+
+#### Listing Fallback Routes
+
+To list the fallback routes in your Mycelium node:
+
+```rhai
+// List fallback routes
+print("\nListing fallback routes:");
+try {
+    let routes = mycelium_list_fallback_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No fallback routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing fallback routes: ${err}`);
+}
+```
+
+This code:
+1. Calls `mycelium_list_fallback_routes()` to get all fallback routes
+2. Iterates through the routes and prints their details
+
+## Sending Messages
+
+Now let's look at how to send messages using the `mycelium_send_message.rhai` example.
+
+```rhai
+// API URL for Mycelium
+let api_url = "http://localhost:1111";
+
+// Send a message
+print("\nSending a message:");
+let destination = "5af:ae6b:dcd8:ffdb:b71:7dde:d3:1033"; // Replace with the actual destination IP address
+let topic = "test_topic";
+let message = "Hello from Rhai sender!";
+let deadline_secs = -10; // Seconds we wait for a reply
+
+try {
+    print(`Attempting to send message to ${destination} on topic '${topic}'`);
+    let result = mycelium_send_message(api_url, destination, topic, message, deadline_secs);
+    print(`result: ${result}`);
+    print(`Message sent: ${result.success}`);
+    if result.id != "" {
+        print(`Message ID: ${result.id}`);
+    }
+} catch(err) {
+    print(`Error sending message: ${err}`);
+}
+```
+
+This code:
+1. Sets the API URL for your Mycelium node
+2. Specifies the destination IP address, topic, message content, and deadline
+3. Calls `mycelium_send_message()` to send the message
+4. Prints the result, including the message ID if successful
+
+### Important Parameters for Sending Messages
+
+- `api_url`: The URL of your Mycelium node's API
+- `destination`: The IP address of the destination node
+- `topic`: The topic to send the message on (must match what the receiver is listening for)
+- `message`: The content of the message
+- `deadline_secs`: Time in seconds to wait for a reply. Use a negative value if you don't want to wait for a reply.
+
+## Receiving Messages
+
+Now let's look at how to receive messages using the `mycelium_receive_message.rhai` example.
+
+```rhai
+// API URL for Mycelium
+let api_url = "http://localhost:2222";
+
+// Receive messages
+print("\nReceiving messages:");
+let receive_topic = "test_topic";
+let wait_deadline_secs = 100; 
+
+print(`Listening for messages on topic '${receive_topic}'...`);
+try {
+    let messages = mycelium_receive_messages(api_url, receive_topic, wait_deadline_secs);
+    
+    if messages.is_empty() {
+        // print("No new messages received in this poll.");
+    } else {
+        print("Received a message:");
+        print(`  Message id: ${messages.id}`);
+        print(`  Message from: ${messages.srcIp}`);
+        print(`  Topic: ${messages.topic}`);
+        print(`  Payload: ${messages.payload}`);
+    }
+} catch(err) {
+    print(`Error receiving messages: ${err}`);
+}
+
+print("Finished attempting to receive messages.");
+```
+
+This code:
+1. Sets the API URL for your Mycelium node
+2. Specifies the topic to listen on and how long to wait for messages
+3. Calls `mycelium_receive_messages()` to receive messages
+4. Processes and prints any received messages
+
+### Important Parameters for Receiving Messages
+
+- `api_url`: The URL of your Mycelium node's API
+- `receive_topic`: The topic to listen for messages on (must match what the sender is using)
+- `wait_deadline_secs`: Time in seconds to wait for messages to arrive. The function will block for this duration if no messages are immediately available.
+
+## Complete Messaging Example
+
+To set up a complete messaging system, you would typically run two instances of Mycelium (node A sender, node B receiver).
+
+1. Run the `mycelium_receive_message.rhai` script to listen for messages. **Fill in the API address of node B**.
+2. Run the `mycelium_send_message.rhai` script to send messages. **Fill in the API address of node A, and fill in the overlay address of node B as destination**.
+
+### Setting Up the Receiver
+
+First, start a Mycelium node and run the receiver script:
+
+```rhai
+// API URL for Mycelium
+let api_url = "http://localhost:2222";  // Your receiver node's API URL
+
+// Receive messages
+let receive_topic = "test_topic";
+let wait_deadline_secs = 100;  // Wait up to 100 seconds for messages
+
+print(`Listening for messages on topic '${receive_topic}'...`);
+try {
+    let messages = mycelium_receive_messages(api_url, receive_topic, wait_deadline_secs);
+    
+    if messages.is_empty() {
+        print("No new messages received in this poll.");
+    } else {
+        print("Received a message:");
+        print(`  Message id: ${messages.id}`);
+        print(`  Message from: ${messages.srcIp}`);
+        print(`  Topic: ${messages.topic}`);
+        print(`  Payload: ${messages.payload}`);
+    }
+} catch(err) {
+    print(`Error receiving messages: ${err}`);
+}
+```
+
+### Setting Up the Sender
+
+Then, on another Mycelium node, run the sender script:
+
+```rhai
+// API URL for Mycelium
+let api_url = "http://localhost:1111";  // Your sender node's API URL
+
+// Send a message
+let destination = "5af:ae6b:dcd8:ffdb:b71:7dde:d3:1033";  // The receiver node's IP address
+let topic = "test_topic";  // Must match the receiver's topic
+let message = "Hello from Rhai sender!";
+let deadline_secs = -10;  // Don't wait for a reply
+
+try {
+    print(`Attempting to send message to ${destination} on topic '${topic}'`);
+    let result = mycelium_send_message(api_url, destination, topic, message, deadline_secs);
+    print(`Message sent: ${result.success}`);
+    if result.id != "" {
+        print(`Message ID: ${result.id}`);
+    }
+} catch(err) {
+    print(`Error sending message: ${err}`);
+}
+```
+
+### Example: setting up 2 different Mycelium peers on same the host and sending/receiving a message
+
+#### Obtain Mycelium
+
+- Download the latest Mycelium binary from https://github.com/threefoldtech/mycelium/releases/
+- Or compile from source
+
+#### Setup
+- Create two different private key files. Each key file should contain exactely 32 bytes. In this example we'll save these files as `sender.bin` and `receiver.bin`. Note: generate your own 32-byte key files, the values below are just used as examples.
+> `echo '9f3d72c1a84be6f027bba94cde015ee839cedb2ac4f2822bfc94449e3e2a1c6a' > sender.bin`
+
+> `echo 'e81c5a76f42bd9a3c73fe0bb2196acdfb6348e99d0b01763a2e57ce3a4e8f5dd' > receiver.bin`
+
+#### Start the nodes
+- **Sender**: this node will have the API server hosted on `127.0.0.1:1111` and the JSON-RPC server on `127.0.0.1:8991`.
+> `sudo ./mycelium --key-file sender.bin --disable-peer-discovery --disable-quic --no-tun --api-addr 127.0.0.1:1111 --jsonrpc-addr 127.0.0.1:8991`
+
+- **Receiver**: this node will have the API server hosted on `127.0.0.1:2222` and the JSON-RPC server on `127.0.0.1:8992`.
+> `sudo ./mycelium --key-file receiver.bin --disable-peer-discovery --disable-quic --no-tun --api-addr 127.0.0.1:2222 --jsonrpc-addr 127.0.0.1:8992 --peers tcp://<UNDERLAY_IP_SENDER>:9651`
+- Obtain the Mycelium overlay IP by running `./mycelium --key-file receiver.bin --api-addr 127.0.0.1:2222 inspect`. **Replace this IP as destination  in the [mycelium_send_message.rhai](../../../examples/mycelium/mycelium_send_message.rhai) example**.
+
+#### Execute the examples
+- First build by executing `./build_herdo.sh` from the SAL root directory
+- `cd target/debug`
+
+- Run the sender script: `sudo ./herodo --path ../../examples/mycelium/mycelium_send_message.rhai`
+```
+Executing: ../../examples/mycelium/mycelium_send_message.rhai
+
+Sending a message:
+Attempting to send message to 50e:6d75:4568:366e:f75:2ac3:bbb1:3fdd on topic 'test_topic'
+result: #{"id": "bfd47dc689a7b826"}
+Message sent: 
+Message ID: bfd47dc689a7b826
+Script executed successfull
+```
+
+- Run the receiver script: `sudo ./herodo --path ../../examples/mycelium/mycelium_receive_message.rhai`
+```
+Executing: ../../examples/mycelium/mycelium_receive_message.rhai
+
+Receiving messages:
+Listening for messages on topic 'test_topic'...
+Received a message:
+  Message id: bfd47dc689a7b826
+  Message from: 45d:26e1:a413:9d08:80ce:71c6:a931:4315
+  Topic: dGVzdF90b3BpYw==
+  Payload: SGVsbG8gZnJvbSBSaGFpIHNlbmRlciE=
+Finished attempting to receive messages.
+Script executed successfully
+```
+> Decoding the payload `SGVsbG8gZnJvbSBSaGFpIHNlbmRlciE=` results in the expected `Hello from Rhai sender!` message. Mission succesful!
+

examples/_archive/container_example.rs

@@ -1,4 +1,4 @@
-// File: /root/code/git.ourworld.tf/herocode/sal/examples/container_example.rs
+// File: /root/code/git.threefold.info/herocode/sal/examples/container_example.rs
 
 use std::error::Error;
 use sal::virt::nerdctl::Container;

examples/containers/buildah.rhai

@@ -121,16 +121,16 @@ println(`Using local image: ${local_image_name}`);
 
 // Tag the image with the localhost prefix for nerdctl compatibility
 println(`Tagging image as ${local_image_name}...`);
-let tag_result = bah_image_tag(final_image_name, local_image_name);
+let tag_result = image_tag(final_image_name, local_image_name);
 
 // Print a command to check if the image exists in buildah
 println("\nTo verify the image was created with buildah, run:");
 println("buildah images");
 
 // Note: If nerdctl cannot find the image, you may need to push it to a registry
-println("\nNote: If nerdctl cannot find the image, you may need to push it to a registry:");
+// println("\nNote: If nerdctl cannot find the image, you may need to push it to a registry:");
-println("buildah push localhost/custom-golang-nginx:latest docker://localhost:5000/custom-golang-nginx:latest");
+// println("buildah push localhost/custom-golang-nginx:latest docker://localhost:5000/custom-golang-nginx:latest");
-println("nerdctl pull localhost:5000/custom-golang-nginx:latest");
+// println("nerdctl pull localhost:5000/custom-golang-nginx:latest");
 
 let container = nerdctl_container_from_image("golang-nginx-demo", local_image_name)
     .with_detach(true)

examples/containers/buildah_run.rhai

@@ -0,0 +1,44 @@
+
+// Now use nerdctl to run a container from the new image
+println("\nStarting container from the new image using nerdctl...");
+
+// Create a container using the builder pattern
+// Use localhost/ prefix to ensure nerdctl uses the local image
+let local_image_name = "localhost/custom-golang-nginx:latest";
+println(`Using local image: ${local_image_name}`);
+
+// Import the image from buildah to nerdctl
+println("Importing image from buildah to nerdctl...");
+process_run("buildah", ["push", "custom-golang-nginx:latest", "docker-daemon:localhost/custom-golang-nginx:latest"]);
+
+let tag_result = nerdctl_image_tag("custom-golang-nginx:latest", local_image_name);
+
+// Tag the image with the localhost prefix for nerdctl compatibility
+// println(`Tagging image as ${local_image_name}...`);
+// let tag_result = bah_image_tag(final_image_name, local_image_name);
+
+// Print a command to check if the image exists in buildah
+println("\nTo verify the image was created with buildah, run:");
+println("buildah images");
+
+// Note: If nerdctl cannot find the image, you may need to push it to a registry
+// println("\nNote: If nerdctl cannot find the image, you may need to push it to a registry:");
+// println("buildah push localhost/custom-golang-nginx:latest docker://localhost:5000/custom-golang-nginx:latest");
+// println("nerdctl pull localhost:5000/custom-golang-nginx:latest");
+
+let container = nerdctl_container_from_image("golang-nginx-demo", local_image_name)
+    .with_detach(true)
+    .with_port("8081:80")  // Map port 80 in the container to 8080 on the host
+    .with_restart_policy("unless-stopped")
+    .build();
+
+// Start the container
+let start_result = container.start();
+
+println("\nWorkflow completed successfully!");
+println("The web server should be running at http://localhost:8081");
+println("You can check container logs with: nerdctl logs golang-nginx-demo");
+println("To stop the container: nerdctl stop golang-nginx-demo");
+println("To remove the container: nerdctl rm golang-nginx-demo");
+
+"Buildah and nerdctl workflow completed successfully!"

examples/containers/nerdctl_install.rhai

@@ -1,42 +0,0 @@
-
-
-
-fn nerdctl_download(){
-    let name="nerdctl";
-    let url="https://github.com/containerd/nerdctl/releases/download/v2.0.4/nerdctl-2.0.4-linux-amd64.tar.gz";
-    download(url,`/tmp/${name}`,20000);
-    copy(`/tmp/${name}/*`,"/root/hero/bin/");
-    delete(`/tmp/${name}`);
-    
-    let name="containerd";
-    let url="https://github.com/containerd/containerd/releases/download/v2.0.4/containerd-2.0.4-linux-amd64.tar.gz";
-    download(url,`/tmp/${name}`,20000);
-    copy(`/tmp/${name}/bin/*`,"/root/hero/bin/");
-    delete(`/tmp/${name}`);
-
-    run("apt-get -y install buildah runc");
-
-    let url="https://github.com/threefoldtech/rfs/releases/download/v2.0.6/rfs";
-    download_file(url,`/tmp/rfs`,10000);
-    chmod_exec("/tmp/rfs");
-    mv(`/tmp/rfs`,"/root/hero/bin/");
-
-}
-
-fn ipfs_download(){
-    let name="ipfs";
-    let url="https://github.com/ipfs/kubo/releases/download/v0.34.1/kubo_v0.34.1_linux-amd64.tar.gz";
-    download(url,`/tmp/${name}`,20);
-    copy(`/tmp/${name}/kubo/ipfs`,"/root/hero/bin/ipfs");
-    // delete(`/tmp/${name}`);
-    
-
-}
-
-
-
-
-nerdctl_download();
-// ipfs_download();
-
-"done"

examples/hero_vault/README.md

@@ -1,64 +1,76 @@
-# Hero Vault Cryptography Examples
+# SAL Vault Examples
 
-This directory contains examples demonstrating the Hero Vault cryptography functionality integrated into the SAL project.
+This directory contains examples demonstrating the SAL Vault functionality.
 
 ## Overview
 
-Hero Vault provides cryptographic operations including:
+SAL Vault provides secure key management and cryptographic operations including:
 
-- Key space management (creation, loading, encryption, decryption)
+- Vault creation and management
-- Keypair management (creation, selection, listing)
+- KeySpace operations (encrypted key-value stores)
-- Digital signatures (signing and verification)
+- Symmetric key generation and operations
-- Symmetric encryption (key generation, encryption, decryption)
+- Asymmetric key operations (signing and verification)
-- Ethereum wallet functionality
+- Secure key derivation from passwords
-- Smart contract interactions
-- Key-value store with encryption
 
-## Example Files
+## Current Status
 
-- `example.rhai` - Basic example demonstrating key management, signing, and encryption
+⚠️ **Note**: The vault module is currently being updated to use Lee's implementation.
-- `advanced_example.rhai` - Advanced example with error handling, conditional logic, and more complex operations
+The Rhai scripting integration is temporarily disabled while we adapt the examples
-- `key_persistence_example.rhai` - Demonstrates creating and saving a key space to disk
+to work with the new vault API.
-- `load_existing_space.rhai` - Shows how to load a previously created key space and use its keypairs
-- `contract_example.rhai` - Demonstrates loading a contract ABI and interacting with smart contracts
-- `agung_send_transaction.rhai` - Demonstrates sending native tokens on the Agung network
-- `agung_contract_with_args.rhai` - Shows how to interact with contracts with arguments on Agung
 
-## Running the Examples
+## Available Operations
 
-You can run the examples using the `herodo` tool that comes with the SAL project:
+- **Vault Management**: Create and manage vault instances
+- **KeySpace Operations**: Open encrypted key-value stores within vaults
+- **Symmetric Encryption**: Generate keys and encrypt/decrypt data
+- **Asymmetric Operations**: Create keypairs, sign messages, verify signatures
 
-```bash
+## Example Files (Legacy - Sameh's Implementation)
-# Run a single example
-herodo --path example.rhai
 
-# Run all examples using the provided script
+⚠️ **These examples are currently archived and use the previous vault implementation**:
-./run_examples.sh
+
+- `_archive/example.rhai` - Basic example demonstrating key management, signing, and encryption
+- `_archive/advanced_example.rhai` - Advanced example with error handling and complex operations
+- `_archive/key_persistence_example.rhai` - Demonstrates creating and saving a key space to disk
+- `_archive/load_existing_space.rhai` - Shows how to load a previously created key space
+- `_archive/contract_example.rhai` - Demonstrates smart contract interactions (Ethereum)
+- `_archive/agung_send_transaction.rhai` - Demonstrates Ethereum transactions on Agung network
+- `_archive/agung_contract_with_args.rhai` - Shows contract interactions with arguments
+
+## Current Implementation (Lee's Vault)
+
+The current vault implementation provides:
+
+```rust
+// Create a new vault
+let vault = Vault::new(&path).await?;
+
+// Open an encrypted keyspace
+let keyspace = vault.open_keyspace("my_space", "password").await?;
+
+// Perform cryptographic operations
+// (API documentation coming soon)
 ```
 
-## Key Space Storage
+## Migration Status
 
-Key spaces are stored in the `~/.hero-vault/key-spaces/` directory by default. Each key space is stored in a separate JSON file named after the key space (e.g., `my_space.json`).
+- ✅ **Vault Core**: Lee's implementation is active
-
+- ✅ **Archive**: Sameh's implementation preserved in `vault/_archive/`
-## Ethereum Functionality
+- ⏳ **Rhai Integration**: Being developed for Lee's implementation
-
+- ⏳ **Examples**: Will be updated to use Lee's API
-The Hero Vault module provides comprehensive Ethereum wallet functionality:
+- ❌ **Ethereum Features**: Not available in Lee's implementation
-
-- Creating and managing wallets for different networks
-- Sending ETH transactions
-- Checking balances
-- Interacting with smart contracts (read and write functions)
-- Support for multiple networks (Ethereum, Gnosis, Peaq, Agung, etc.)
 
 ## Security
 
-Key spaces are encrypted with ChaCha20Poly1305 using a key derived from the provided password. The encryption ensures that the key material is secure at rest.
+The vault uses:
 
-## Best Practices
+- **ChaCha20Poly1305** for symmetric encryption
+- **Password-based key derivation** for keyspace encryption
+- **Secure key storage** with proper isolation
 
-1. **Use Strong Passwords**: Since the security of your key spaces depends on the strength of your passwords, use strong, unique passwords.
+## Next Steps
-2. **Backup Key Spaces**: Regularly backup your key spaces directory to prevent data loss.
+
-3. **Script Organization**: Split your scripts into logical units, with separate scripts for key creation and key usage.
+1. **Rhai Integration**: Implement Rhai bindings for Lee's vault
-4. **Error Handling**: Always check the return values of functions to ensure operations succeeded before proceeding.
+2. **New Examples**: Create examples using Lee's simpler API
-5. **Network Selection**: When working with Ethereum functionality, be explicit about which network you're targeting to avoid confusion.
+3. **Documentation**: Complete API documentation for Lee's implementation
-6. **Gas Management**: For Ethereum transactions, consider gas costs and set appropriate gas limits.
+4. **Migration Guide**: Provide guidance for users migrating from Sameh's implementation

examples/kubernetes/basic_operations.rhai

@@ -0,0 +1,72 @@
+//! Basic Kubernetes operations example
+//!
+//! This script demonstrates basic Kubernetes operations using the SAL Kubernetes module.
+//! 
+//! Prerequisites:
+//! - A running Kubernetes cluster
+//! - Valid kubeconfig file or in-cluster configuration
+//! - Appropriate permissions for the operations
+//!
+//! Usage:
+//!   herodo examples/kubernetes/basic_operations.rhai
+
+print("=== SAL Kubernetes Basic Operations Example ===");
+
+// Create a KubernetesManager for the default namespace
+print("Creating KubernetesManager for 'default' namespace...");
+let km = kubernetes_manager_new("default");
+print("✓ KubernetesManager created for namespace: " + namespace(km));
+
+// List all pods in the namespace
+print("\n--- Listing Pods ---");
+let pods = pods_list(km);
+print("Found " + pods.len() + " pods in the namespace:");
+for pod in pods {
+    print("  - " + pod);
+}
+
+// List all services in the namespace
+print("\n--- Listing Services ---");
+let services = services_list(km);
+print("Found " + services.len() + " services in the namespace:");
+for service in services {
+    print("  - " + service);
+}
+
+// List all deployments in the namespace
+print("\n--- Listing Deployments ---");
+let deployments = deployments_list(km);
+print("Found " + deployments.len() + " deployments in the namespace:");
+for deployment in deployments {
+    print("  - " + deployment);
+}
+
+// Get resource counts
+print("\n--- Resource Counts ---");
+let counts = resource_counts(km);
+print("Resource counts in namespace '" + namespace(km) + "':");
+for resource_type in counts.keys() {
+    print("  " + resource_type + ": " + counts[resource_type]);
+}
+
+// List all namespaces (cluster-wide operation)
+print("\n--- Listing All Namespaces ---");
+let namespaces = namespaces_list(km);
+print("Found " + namespaces.len() + " namespaces in the cluster:");
+for ns in namespaces {
+    print("  - " + ns);
+}
+
+// Check if specific namespaces exist
+print("\n--- Checking Namespace Existence ---");
+let test_namespaces = ["default", "kube-system", "non-existent-namespace"];
+for ns in test_namespaces {
+    let exists = namespace_exists(km, ns);
+    if exists {
+        print("✓ Namespace '" + ns + "' exists");
+    } else {
+        print("✗ Namespace '" + ns + "' does not exist");
+    }
+}
+
+print("\n=== Example completed successfully! ===");

examples/kubernetes/clusters/generic.rs

@@ -0,0 +1,134 @@
+//! Generic Application Deployment Example
+//!
+//! This example shows how to deploy any containerized application using the
+//! KubernetesManager convenience methods. This works for any Docker image.
+
+use sal_kubernetes::KubernetesManager;
+use std::collections::HashMap;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create Kubernetes manager
+    let km = KubernetesManager::new("default").await?;
+
+    // Clean up any existing resources first
+    println!("=== Cleaning up existing resources ===");
+    let apps_to_clean = ["web-server", "node-app", "mongodb"];
+
+    for app in &apps_to_clean {
+        match km.deployment_delete(app).await {
+            Ok(_) => println!("✓ Deleted existing deployment: {}", app),
+            Err(_) => println!("✓ No existing deployment to delete: {}", app),
+        }
+
+        match km.service_delete(app).await {
+            Ok(_) => println!("✓ Deleted existing service: {}", app),
+            Err(_) => println!("✓ No existing service to delete: {}", app),
+        }
+    }
+
+    // Example 1: Simple web server deployment
+    println!("\n=== Example 1: Simple Nginx Web Server ===");
+
+    km.deploy_application("web-server", "nginx:latest", 2, 80, None, None)
+        .await?;
+    println!("✅ Nginx web server deployed!");
+
+    // Example 2: Node.js application with labels
+    println!("\n=== Example 2: Node.js Application ===");
+
+    let mut node_labels = HashMap::new();
+    node_labels.insert("app".to_string(), "node-app".to_string());
+    node_labels.insert("tier".to_string(), "backend".to_string());
+    node_labels.insert("environment".to_string(), "production".to_string());
+
+    // Configure Node.js environment variables
+    let mut node_env_vars = HashMap::new();
+    node_env_vars.insert("NODE_ENV".to_string(), "production".to_string());
+    node_env_vars.insert("PORT".to_string(), "3000".to_string());
+    node_env_vars.insert("LOG_LEVEL".to_string(), "info".to_string());
+    node_env_vars.insert("MAX_CONNECTIONS".to_string(), "1000".to_string());
+
+    km.deploy_application(
+        "node-app",          // name
+        "node:18-alpine",    // image
+        3,                   // replicas - scale to 3 instances
+        3000,                // port
+        Some(node_labels),   // labels
+        Some(node_env_vars), // environment variables
+    )
+    .await?;
+
+    println!("✅ Node.js application deployed!");
+
+    // Example 3: Database deployment (any database)
+    println!("\n=== Example 3: MongoDB Database ===");
+
+    let mut mongo_labels = HashMap::new();
+    mongo_labels.insert("app".to_string(), "mongodb".to_string());
+    mongo_labels.insert("type".to_string(), "database".to_string());
+    mongo_labels.insert("engine".to_string(), "mongodb".to_string());
+
+    // Configure MongoDB environment variables
+    let mut mongo_env_vars = HashMap::new();
+    mongo_env_vars.insert(
+        "MONGO_INITDB_ROOT_USERNAME".to_string(),
+        "admin".to_string(),
+    );
+    mongo_env_vars.insert(
+        "MONGO_INITDB_ROOT_PASSWORD".to_string(),
+        "mongopassword".to_string(),
+    );
+    mongo_env_vars.insert("MONGO_INITDB_DATABASE".to_string(), "myapp".to_string());
+
+    km.deploy_application(
+        "mongodb",            // name
+        "mongo:6.0",          // image
+        1,                    // replicas - single instance for simplicity
+        27017,                // port
+        Some(mongo_labels),   // labels
+        Some(mongo_env_vars), // environment variables
+    )
+    .await?;
+
+    println!("✅ MongoDB deployed!");
+
+    // Check status of all deployments
+    println!("\n=== Checking Deployment Status ===");
+
+    let deployments = km.deployments_list().await?;
+
+    for deployment in &deployments {
+        if let Some(name) = &deployment.metadata.name {
+            let total_replicas = deployment
+                .spec
+                .as_ref()
+                .and_then(|s| s.replicas)
+                .unwrap_or(0);
+            let ready_replicas = deployment
+                .status
+                .as_ref()
+                .and_then(|s| s.ready_replicas)
+                .unwrap_or(0);
+
+            println!(
+                "{}: {}/{} replicas ready",
+                name, ready_replicas, total_replicas
+            );
+        }
+    }
+
+    println!("\n🎉 All deployments completed!");
+    println!("\n💡 Key Points:");
+    println!("  • Any Docker image can be deployed using this simple interface");
+    println!("  • Use labels to organize and identify your applications");
+    println!(
+        "  • The same method works for databases, web servers, APIs, and any containerized app"
+    );
+    println!("  • For advanced configuration, use the individual KubernetesManager methods");
+    println!(
+        "  • Environment variables and resource limits can be added via direct Kubernetes API"
+    );
+
+    Ok(())
+}

examples/kubernetes/clusters/postgres.rhai

@@ -0,0 +1,79 @@
+//! PostgreSQL Cluster Deployment Example (Rhai)
+//!
+//! This script shows how to deploy a PostgreSQL cluster using Rhai scripting
+//! with the KubernetesManager convenience methods.
+
+print("=== PostgreSQL Cluster Deployment ===");
+
+// Create Kubernetes manager for the database namespace
+print("Creating Kubernetes manager for 'database' namespace...");
+let km = kubernetes_manager_new("database");
+print("✓ Kubernetes manager created");
+
+// Create the namespace if it doesn't exist
+print("Creating namespace 'database' if it doesn't exist...");
+try {
+    create_namespace(km, "database");
+    print("✓ Namespace 'database' created");
+} catch(e) {
+    if e.to_string().contains("already exists") {
+        print("✓ Namespace 'database' already exists");
+    } else {
+        print("⚠️ Warning: " + e);
+    }
+}
+
+// Clean up any existing resources first
+print("\nCleaning up any existing PostgreSQL resources...");
+try {
+    delete_deployment(km, "postgres-cluster");
+    print("✓ Deleted existing deployment");
+} catch(e) {
+    print("✓ No existing deployment to delete");
+}
+
+try {
+    delete_service(km, "postgres-cluster");
+    print("✓ Deleted existing service");
+} catch(e) {
+    print("✓ No existing service to delete");
+}
+
+// Create PostgreSQL cluster using the convenience method
+print("\nDeploying PostgreSQL cluster...");
+
+try {
+    // Deploy PostgreSQL using the convenience method
+    let result = deploy_application(km, "postgres-cluster", "postgres:15", 2, 5432, #{
+        "app": "postgres-cluster",
+        "type": "database",
+        "engine": "postgresql"
+    }, #{
+        "POSTGRES_DB": "myapp",
+        "POSTGRES_USER": "postgres",
+        "POSTGRES_PASSWORD": "secretpassword",
+        "PGDATA": "/var/lib/postgresql/data/pgdata"
+    });
+    print("✓ " + result);
+
+    print("\n✅ PostgreSQL cluster deployed successfully!");
+
+    print("\n📋 Connection Information:");
+    print("  Host: postgres-cluster.database.svc.cluster.local");
+    print("  Port: 5432");
+    print("  Database: postgres (default)");
+    print("  Username: postgres (default)");
+
+    print("\n🔧 To connect from another pod:");
+    print("  psql -h postgres-cluster.database.svc.cluster.local -U postgres");
+
+    print("\n💡 Next steps:");
+    print("  • Set POSTGRES_PASSWORD environment variable");
+    print("  • Configure persistent storage");
+    print("  • Set up backup and monitoring");
+
+} catch(e) {
+    print("❌ Failed to deploy PostgreSQL cluster: " + e);
+}
+
+print("\n=== Deployment Complete ===");

examples/kubernetes/clusters/postgres.rs

@@ -0,0 +1,112 @@
+//! PostgreSQL Cluster Deployment Example
+//!
+//! This example shows how to deploy a PostgreSQL cluster using the
+//! KubernetesManager convenience methods.
+
+use sal_kubernetes::KubernetesManager;
+use std::collections::HashMap;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create Kubernetes manager for the database namespace
+    let km = KubernetesManager::new("database").await?;
+
+    // Create the namespace if it doesn't exist
+    println!("Creating namespace 'database' if it doesn't exist...");
+    match km.namespace_create("database").await {
+        Ok(_) => println!("✓ Namespace 'database' created"),
+        Err(e) => {
+            if e.to_string().contains("already exists") {
+                println!("✓ Namespace 'database' already exists");
+            } else {
+                return Err(e.into());
+            }
+        }
+    }
+
+    // Clean up any existing resources first
+    println!("Cleaning up any existing PostgreSQL resources...");
+    match km.deployment_delete("postgres-cluster").await {
+        Ok(_) => println!("✓ Deleted existing deployment"),
+        Err(_) => println!("✓ No existing deployment to delete"),
+    }
+
+    match km.service_delete("postgres-cluster").await {
+        Ok(_) => println!("✓ Deleted existing service"),
+        Err(_) => println!("✓ No existing service to delete"),
+    }
+
+    // Configure PostgreSQL-specific labels
+    let mut labels = HashMap::new();
+    labels.insert("app".to_string(), "postgres-cluster".to_string());
+    labels.insert("type".to_string(), "database".to_string());
+    labels.insert("engine".to_string(), "postgresql".to_string());
+
+    // Configure PostgreSQL environment variables
+    let mut env_vars = HashMap::new();
+    env_vars.insert("POSTGRES_DB".to_string(), "myapp".to_string());
+    env_vars.insert("POSTGRES_USER".to_string(), "postgres".to_string());
+    env_vars.insert(
+        "POSTGRES_PASSWORD".to_string(),
+        "secretpassword".to_string(),
+    );
+    env_vars.insert(
+        "PGDATA".to_string(),
+        "/var/lib/postgresql/data/pgdata".to_string(),
+    );
+
+    // Deploy the PostgreSQL cluster using the convenience method
+    println!("Deploying PostgreSQL cluster...");
+    km.deploy_application(
+        "postgres-cluster", // name
+        "postgres:15",      // image
+        2,                  // replicas (1 master + 1 replica)
+        5432,               // port
+        Some(labels),       // labels
+        Some(env_vars),     // environment variables
+    )
+    .await?;
+
+    println!("✅ PostgreSQL cluster deployed successfully!");
+
+    // Check deployment status
+    let deployments = km.deployments_list().await?;
+    let postgres_deployment = deployments
+        .iter()
+        .find(|d| d.metadata.name.as_ref() == Some(&"postgres-cluster".to_string()));
+
+    if let Some(deployment) = postgres_deployment {
+        let total_replicas = deployment
+            .spec
+            .as_ref()
+            .and_then(|s| s.replicas)
+            .unwrap_or(0);
+        let ready_replicas = deployment
+            .status
+            .as_ref()
+            .and_then(|s| s.ready_replicas)
+            .unwrap_or(0);
+
+        println!(
+            "Deployment status: {}/{} replicas ready",
+            ready_replicas, total_replicas
+        );
+    }
+
+    println!("\n📋 Connection Information:");
+    println!("  Host: postgres-cluster.database.svc.cluster.local");
+    println!("  Port: 5432");
+    println!("  Database: postgres (default)");
+    println!("  Username: postgres (default)");
+    println!("  Password: Set POSTGRES_PASSWORD environment variable");
+
+    println!("\n🔧 To connect from another pod:");
+    println!("  psql -h postgres-cluster.database.svc.cluster.local -U postgres");
+
+    println!("\n💡 Next steps:");
+    println!("  • Set environment variables for database credentials");
+    println!("  • Add persistent volume claims for data storage");
+    println!("  • Configure backup and monitoring");
+
+    Ok(())
+}

examples/kubernetes/clusters/redis.rhai

@@ -0,0 +1,79 @@
+//! Redis Cluster Deployment Example (Rhai)
+//!
+//! This script shows how to deploy a Redis cluster using Rhai scripting
+//! with the KubernetesManager convenience methods.
+
+print("=== Redis Cluster Deployment ===");
+
+// Create Kubernetes manager for the cache namespace
+print("Creating Kubernetes manager for 'cache' namespace...");
+let km = kubernetes_manager_new("cache");
+print("✓ Kubernetes manager created");
+
+// Create the namespace if it doesn't exist
+print("Creating namespace 'cache' if it doesn't exist...");
+try {
+    create_namespace(km, "cache");
+    print("✓ Namespace 'cache' created");
+} catch(e) {
+    if e.to_string().contains("already exists") {
+        print("✓ Namespace 'cache' already exists");
+    } else {
+        print("⚠️ Warning: " + e);
+    }
+}
+
+// Clean up any existing resources first
+print("\nCleaning up any existing Redis resources...");
+try {
+    delete_deployment(km, "redis-cluster");
+    print("✓ Deleted existing deployment");
+} catch(e) {
+    print("✓ No existing deployment to delete");
+}
+
+try {
+    delete_service(km, "redis-cluster");
+    print("✓ Deleted existing service");
+} catch(e) {
+    print("✓ No existing service to delete");
+}
+
+// Create Redis cluster using the convenience method
+print("\nDeploying Redis cluster...");
+
+try {
+    // Deploy Redis using the convenience method
+    let result = deploy_application(km, "redis-cluster", "redis:7-alpine", 3, 6379, #{
+        "app": "redis-cluster",
+        "type": "cache",
+        "engine": "redis"
+    }, #{
+        "REDIS_PASSWORD": "redispassword",
+        "REDIS_PORT": "6379",
+        "REDIS_DATABASES": "16",
+        "REDIS_MAXMEMORY": "256mb",
+        "REDIS_MAXMEMORY_POLICY": "allkeys-lru"
+    });
+    print("✓ " + result);
+
+    print("\n✅ Redis cluster deployed successfully!");
+
+    print("\n📋 Connection Information:");
+    print("  Host: redis-cluster.cache.svc.cluster.local");
+    print("  Port: 6379");
+
+    print("\n🔧 To connect from another pod:");
+    print("  redis-cli -h redis-cluster.cache.svc.cluster.local");
+
+    print("\n💡 Next steps:");
+    print("  • Configure Redis authentication");
+    print("  • Set up Redis clustering configuration");
+    print("  • Add persistent storage");
+    print("  • Configure memory policies");
+
+} catch(e) {
+    print("❌ Failed to deploy Redis cluster: " + e);
+}
+
+print("\n=== Deployment Complete ===");

examples/kubernetes/clusters/redis.rs

@@ -0,0 +1,109 @@
+//! Redis Cluster Deployment Example
+//!
+//! This example shows how to deploy a Redis cluster using the
+//! KubernetesManager convenience methods.
+
+use sal_kubernetes::KubernetesManager;
+use std::collections::HashMap;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create Kubernetes manager for the cache namespace
+    let km = KubernetesManager::new("cache").await?;
+
+    // Create the namespace if it doesn't exist
+    println!("Creating namespace 'cache' if it doesn't exist...");
+    match km.namespace_create("cache").await {
+        Ok(_) => println!("✓ Namespace 'cache' created"),
+        Err(e) => {
+            if e.to_string().contains("already exists") {
+                println!("✓ Namespace 'cache' already exists");
+            } else {
+                return Err(e.into());
+            }
+        }
+    }
+
+    // Clean up any existing resources first
+    println!("Cleaning up any existing Redis resources...");
+    match km.deployment_delete("redis-cluster").await {
+        Ok(_) => println!("✓ Deleted existing deployment"),
+        Err(_) => println!("✓ No existing deployment to delete"),
+    }
+
+    match km.service_delete("redis-cluster").await {
+        Ok(_) => println!("✓ Deleted existing service"),
+        Err(_) => println!("✓ No existing service to delete"),
+    }
+
+    // Configure Redis-specific labels
+    let mut labels = HashMap::new();
+    labels.insert("app".to_string(), "redis-cluster".to_string());
+    labels.insert("type".to_string(), "cache".to_string());
+    labels.insert("engine".to_string(), "redis".to_string());
+
+    // Configure Redis environment variables
+    let mut env_vars = HashMap::new();
+    env_vars.insert("REDIS_PASSWORD".to_string(), "redispassword".to_string());
+    env_vars.insert("REDIS_PORT".to_string(), "6379".to_string());
+    env_vars.insert("REDIS_DATABASES".to_string(), "16".to_string());
+    env_vars.insert("REDIS_MAXMEMORY".to_string(), "256mb".to_string());
+    env_vars.insert(
+        "REDIS_MAXMEMORY_POLICY".to_string(),
+        "allkeys-lru".to_string(),
+    );
+
+    // Deploy the Redis cluster using the convenience method
+    println!("Deploying Redis cluster...");
+    km.deploy_application(
+        "redis-cluster",  // name
+        "redis:7-alpine", // image
+        3,                // replicas (Redis cluster nodes)
+        6379,             // port
+        Some(labels),     // labels
+        Some(env_vars),   // environment variables
+    )
+    .await?;
+
+    println!("✅ Redis cluster deployed successfully!");
+
+    // Check deployment status
+    let deployments = km.deployments_list().await?;
+    let redis_deployment = deployments
+        .iter()
+        .find(|d| d.metadata.name.as_ref() == Some(&"redis-cluster".to_string()));
+
+    if let Some(deployment) = redis_deployment {
+        let total_replicas = deployment
+            .spec
+            .as_ref()
+            .and_then(|s| s.replicas)
+            .unwrap_or(0);
+        let ready_replicas = deployment
+            .status
+            .as_ref()
+            .and_then(|s| s.ready_replicas)
+            .unwrap_or(0);
+
+        println!(
+            "Deployment status: {}/{} replicas ready",
+            ready_replicas, total_replicas
+        );
+    }
+
+    println!("\n📋 Connection Information:");
+    println!("  Host: redis-cluster.cache.svc.cluster.local");
+    println!("  Port: 6379");
+    println!("  Password: Configure REDIS_PASSWORD environment variable");
+
+    println!("\n🔧 To connect from another pod:");
+    println!("  redis-cli -h redis-cluster.cache.svc.cluster.local");
+
+    println!("\n💡 Next steps:");
+    println!("  • Configure Redis authentication with environment variables");
+    println!("  • Set up Redis clustering configuration");
+    println!("  • Add persistent volume claims for data persistence");
+    println!("  • Configure memory limits and eviction policies");
+
+    Ok(())
+}

examples/kubernetes/multi_namespace_operations.rhai

@@ -0,0 +1,208 @@
+//! Multi-namespace Kubernetes operations example
+//!
+//! This script demonstrates working with multiple namespaces and comparing resources across them.
+//! 
+//! Prerequisites:
+//! - A running Kubernetes cluster
+//! - Valid kubeconfig file or in-cluster configuration
+//! - Appropriate permissions for the operations
+//!
+//! Usage:
+//!   herodo examples/kubernetes/multi_namespace_operations.rhai
+
+print("=== SAL Kubernetes Multi-Namespace Operations Example ===");
+
+// Define namespaces to work with
+let target_namespaces = ["default", "kube-system"];
+let managers = #{};
+
+print("Creating managers for multiple namespaces...");
+
+// Create managers for each namespace
+for ns in target_namespaces {
+    try {
+        let km = kubernetes_manager_new(ns);
+        managers[ns] = km;
+        print("✓ Created manager for namespace: " + ns);
+    } catch(e) {
+        print("✗ Failed to create manager for " + ns + ": " + e);
+    }
+}
+
+// Function to safely get resource counts
+fn get_safe_counts(km) {
+    try {
+        return resource_counts(km);
+    } catch(e) {
+        print("  Warning: Could not get resource counts - " + e);
+        return #{};
+    }
+}
+
+// Function to safely get pod list
+fn get_safe_pods(km) {
+    try {
+        return pods_list(km);
+    } catch(e) {
+        print("  Warning: Could not list pods - " + e);
+        return [];
+    }
+}
+
+// Compare resource counts across namespaces
+print("\n--- Resource Comparison Across Namespaces ---");
+let total_resources = #{};
+
+for ns in target_namespaces {
+    if ns in managers {
+        let km = managers[ns];
+        print("\nNamespace: " + ns);
+        let counts = get_safe_counts(km);
+        
+        for resource_type in counts.keys() {
+            let count = counts[resource_type];
+            print("  " + resource_type + ": " + count);
+            
+            // Accumulate totals
+            if resource_type in total_resources {
+                total_resources[resource_type] = total_resources[resource_type] + count;
+            } else {
+                total_resources[resource_type] = count;
+            }
+        }
+    }
+}
+
+print("\n--- Total Resources Across All Namespaces ---");
+for resource_type in total_resources.keys() {
+    print("Total " + resource_type + ": " + total_resources[resource_type]);
+}
+
+// Find namespaces with the most resources
+print("\n--- Namespace Resource Analysis ---");
+let namespace_totals = #{};
+
+for ns in target_namespaces {
+    if ns in managers {
+        let km = managers[ns];
+        let counts = get_safe_counts(km);
+        let total = 0;
+        
+        for resource_type in counts.keys() {
+            total = total + counts[resource_type];
+        }
+        
+        namespace_totals[ns] = total;
+        print("Namespace '" + ns + "' has " + total + " total resources");
+    }
+}
+
+// Find the busiest namespace
+let busiest_ns = "";
+let max_resources = 0;
+for ns in namespace_totals.keys() {
+    if namespace_totals[ns] > max_resources {
+        max_resources = namespace_totals[ns];
+        busiest_ns = ns;
+    }
+}
+
+if busiest_ns != "" {
+    print("🏆 Busiest namespace: '" + busiest_ns + "' with " + max_resources + " resources");
+}
+
+// Detailed pod analysis
+print("\n--- Pod Analysis Across Namespaces ---");
+let all_pods = [];
+
+for ns in target_namespaces {
+    if ns in managers {
+        let km = managers[ns];
+        let pods = get_safe_pods(km);
+        
+        print("\nNamespace '" + ns + "' pods:");
+        if pods.len() == 0 {
+            print("  (no pods)");
+        } else {
+            for pod in pods {
+                print("  - " + pod);
+                all_pods.push(ns + "/" + pod);
+            }
+        }
+    }
+}
+
+print("\n--- All Pods Summary ---");
+print("Total pods across all namespaces: " + all_pods.len());
+
+// Look for common pod name patterns
+print("\n--- Pod Name Pattern Analysis ---");
+let patterns = #{
+    "system": 0,
+    "kube": 0,
+    "coredns": 0,
+    "proxy": 0,
+    "controller": 0
+};
+
+for pod_full_name in all_pods {
+    let pod_name = pod_full_name.to_lower();
+    
+    for pattern in patterns.keys() {
+        if pod_name.contains(pattern) {
+            patterns[pattern] = patterns[pattern] + 1;
+        }
+    }
+}
+
+print("Common pod name patterns found:");
+for pattern in patterns.keys() {
+    if patterns[pattern] > 0 {
+        print("  '" + pattern + "': " + patterns[pattern] + " pods");
+    }
+}
+
+// Namespace health check
+print("\n--- Namespace Health Check ---");
+for ns in target_namespaces {
+    if ns in managers {
+        let km = managers[ns];
+        print("\nChecking namespace: " + ns);
+        
+        // Check if namespace exists (should always be true for our managers)
+        let exists = namespace_exists(km, ns);
+        if exists {
+            print("  ✓ Namespace exists and is accessible");
+        } else {
+            print("  ✗ Namespace existence check failed");
+        }
+        
+        // Try to get resource counts as a health indicator
+        let counts = get_safe_counts(km);
+        if counts.len() > 0 {
+            print("  ✓ Can access resources (" + counts.len() + " resource types)");
+        } else {
+            print("  ⚠ No resources found or access limited");
+        }
+    }
+}
+
+// Create a summary report
+print("\n--- Summary Report ---");
+print("Namespaces analyzed: " + target_namespaces.len());
+print("Total unique resource types: " + total_resources.len());
+
+let grand_total = 0;
+for resource_type in total_resources.keys() {
+    grand_total = grand_total + total_resources[resource_type];
+}
+print("Grand total resources: " + grand_total);
+
+print("\nResource breakdown:");
+for resource_type in total_resources.keys() {
+    let count = total_resources[resource_type];
+    let percentage = (count * 100) / grand_total;
+    print("  " + resource_type + ": " + count + " (" + percentage + "%)");
+}
+
+print("\n=== Multi-namespace operations example completed! ===");

examples/kubernetes/namespace_management.rhai

@@ -0,0 +1,95 @@
+//! Kubernetes namespace management example
+//!
+//! This script demonstrates namespace creation and management operations.
+//! 
+//! Prerequisites:
+//! - A running Kubernetes cluster
+//! - Valid kubeconfig file or in-cluster configuration
+//! - Permissions to create and manage namespaces
+//!
+//! Usage:
+//!   herodo examples/kubernetes/namespace_management.rhai
+
+print("=== SAL Kubernetes Namespace Management Example ===");
+
+// Create a KubernetesManager
+let km = kubernetes_manager_new("default");
+print("Created KubernetesManager for namespace: " + namespace(km));
+
+// Define test namespace names
+let test_namespaces = [
+    "sal-test-namespace-1",
+    "sal-test-namespace-2", 
+    "sal-example-app"
+];
+
+print("\n--- Creating Test Namespaces ---");
+for ns in test_namespaces {
+    print("Creating namespace: " + ns);
+    try {
+        namespace_create(km, ns);
+        print("✓ Successfully created namespace: " + ns);
+    } catch(e) {
+        print("✗ Failed to create namespace " + ns + ": " + e);
+    }
+}
+
+// Wait a moment for namespaces to be created
+print("\nWaiting for namespaces to be ready...");
+
+// Verify namespaces were created
+print("\n--- Verifying Namespace Creation ---");
+for ns in test_namespaces {
+    let exists = namespace_exists(km, ns);
+    if exists {
+        print("✓ Namespace '" + ns + "' exists");
+    } else {
+        print("✗ Namespace '" + ns + "' was not found");
+    }
+}
+
+// List all namespaces to see our new ones
+print("\n--- Current Namespaces ---");
+let all_namespaces = namespaces_list(km);
+print("Total namespaces in cluster: " + all_namespaces.len());
+for ns in all_namespaces {
+    if ns.starts_with("sal-") {
+        print("  🔹 " + ns + " (created by this example)");
+    } else {
+        print("  - " + ns);
+    }
+}
+
+// Test idempotent creation (creating the same namespace again)
+print("\n--- Testing Idempotent Creation ---");
+let test_ns = test_namespaces[0];
+print("Attempting to create existing namespace: " + test_ns);
+try {
+    namespace_create(km, test_ns);
+    print("✓ Idempotent creation successful (no error for existing namespace)");
+} catch(e) {
+    print("✗ Unexpected error during idempotent creation: " + e);
+}
+
+// Create managers for the new namespaces and check their properties
+print("\n--- Creating Managers for New Namespaces ---");
+for ns in test_namespaces {
+    try {
+        let ns_km = kubernetes_manager_new(ns);
+        print("✓ Created manager for namespace: " + namespace(ns_km));
+        
+        // Get resource counts for the new namespace (should be mostly empty)
+        let counts = resource_counts(ns_km);
+        print("  Resource counts: " + counts);
+    } catch(e) {
+        print("✗ Failed to create manager for " + ns + ": " + e);
+    }
+}
+
+print("\n--- Cleanup Instructions ---");
+print("To clean up the test namespaces created by this example, run:");
+for ns in test_namespaces {
+    print("  kubectl delete namespace " + ns);
+}
+
+print("\n=== Namespace management example completed! ===");

examples/kubernetes/pattern_deletion.rhai

@@ -0,0 +1,157 @@
+//! Kubernetes pattern-based deletion example
+//!
+//! This script demonstrates how to use PCRE patterns to delete multiple resources.
+//! 
+//! ⚠️  WARNING: This example includes actual deletion operations!
+//! ⚠️  Only run this in a test environment!
+//! 
+//! Prerequisites:
+//! - A running Kubernetes cluster (preferably a test cluster)
+//! - Valid kubeconfig file or in-cluster configuration
+//! - Permissions to delete resources
+//!
+//! Usage:
+//!   herodo examples/kubernetes/pattern_deletion.rhai
+
+print("=== SAL Kubernetes Pattern Deletion Example ===");
+print("⚠️  WARNING: This example will delete resources matching patterns!");
+print("⚠️  Only run this in a test environment!");
+
+// Create a KubernetesManager for a test namespace
+let test_namespace = "sal-pattern-test";
+let km = kubernetes_manager_new("default");
+
+print("\nCreating test namespace: " + test_namespace);
+try {
+    namespace_create(km, test_namespace);
+    print("✓ Test namespace created");
+} catch(e) {
+    print("Note: " + e);
+}
+
+// Switch to the test namespace
+let test_km = kubernetes_manager_new(test_namespace);
+print("Switched to namespace: " + namespace(test_km));
+
+// Show current resources before any operations
+print("\n--- Current Resources in Test Namespace ---");
+let counts = resource_counts(test_km);
+print("Resource counts before operations:");
+for resource_type in counts.keys() {
+    print("  " + resource_type + ": " + counts[resource_type]);
+}
+
+// List current pods to see what we're working with
+let current_pods = pods_list(test_km);
+print("\nCurrent pods in namespace:");
+if current_pods.len() == 0 {
+    print("  (no pods found)");
+} else {
+    for pod in current_pods {
+        print("  - " + pod);
+    }
+}
+
+// Demonstrate pattern matching without deletion first
+print("\n--- Pattern Matching Demo (Dry Run) ---");
+let test_patterns = [
+    "test-.*",           // Match anything starting with "test-"
+    ".*-temp$",          // Match anything ending with "-temp"
+    "demo-pod-.*",       // Match demo pods
+    "nginx-.*",          // Match nginx pods
+    "app-[0-9]+",        // Match app-1, app-2, etc.
+];
+
+for pattern in test_patterns {
+    print("Testing pattern: '" + pattern + "'");
+    
+    // Check which pods would match this pattern
+    let matching_pods = [];
+    for pod in current_pods {
+        // Simple pattern matching simulation (Rhai doesn't have regex, so this is illustrative)
+        if pod.contains("test") && pattern == "test-.*" {
+            matching_pods.push(pod);
+        } else if pod.contains("temp") && pattern == ".*-temp$" {
+            matching_pods.push(pod);
+        } else if pod.contains("demo") && pattern == "demo-pod-.*" {
+            matching_pods.push(pod);
+        } else if pod.contains("nginx") && pattern == "nginx-.*" {
+            matching_pods.push(pod);
+        }
+    }
+    
+    print("  Would match " + matching_pods.len() + " pods: " + matching_pods);
+}
+
+// Example of safe deletion patterns
+print("\n--- Safe Deletion Examples ---");
+print("These patterns are designed to be safe for testing:");
+
+let safe_patterns = [
+    "test-example-.*",      // Very specific test resources
+    "sal-demo-.*",          // SAL demo resources
+    "temp-resource-.*",     // Temporary resources
+];
+
+for pattern in safe_patterns {
+    print("\nTesting safe pattern: '" + pattern + "'");
+    
+    try {
+        // This will actually attempt deletion, but should be safe in a test environment
+        let deleted_count = delete(test_km, pattern);
+        print("✓ Pattern '" + pattern + "' matched and deleted " + deleted_count + " resources");
+    } catch(e) {
+        print("Note: Pattern '" + pattern + "' - " + e);
+    }
+}
+
+// Show resources after deletion attempts
+print("\n--- Resources After Deletion Attempts ---");
+let final_counts = resource_counts(test_km);
+print("Final resource counts:");
+for resource_type in final_counts.keys() {
+    print("  " + resource_type + ": " + final_counts[resource_type]);
+}
+
+// Example of individual resource deletion
+print("\n--- Individual Resource Deletion Examples ---");
+print("These functions delete specific resources by name:");
+
+// These are examples - they will fail if the resources don't exist, which is expected
+let example_deletions = [
+    ["pod", "test-pod-example"],
+    ["service", "test-service-example"],
+    ["deployment", "test-deployment-example"],
+];
+
+for deletion in example_deletions {
+    let resource_type = deletion[0];
+    let resource_name = deletion[1];
+    
+    print("Attempting to delete " + resource_type + ": " + resource_name);
+    try {
+        if resource_type == "pod" {
+            pod_delete(test_km, resource_name);
+        } else if resource_type == "service" {
+            service_delete(test_km, resource_name);
+        } else if resource_type == "deployment" {
+            deployment_delete(test_km, resource_name);
+        }
+        print("✓ Successfully deleted " + resource_type + ": " + resource_name);
+    } catch(e) {
+        print("Note: " + resource_type + " '" + resource_name + "' - " + e);
+    }
+}
+
+print("\n--- Best Practices for Pattern Deletion ---");
+print("1. Always test patterns in a safe environment first");
+print("2. Use specific patterns rather than broad ones");
+print("3. Consider using dry-run approaches when possible");
+print("4. Have backups or be able to recreate resources");
+print("5. Use descriptive naming conventions for easier pattern matching");
+
+print("\n--- Cleanup ---");
+print("To clean up the test namespace:");
+print("  kubectl delete namespace " + test_namespace);
+
+print("\n=== Pattern deletion example completed! ===");

examples/kubernetes/test_registration.rhai

@@ -0,0 +1,33 @@
+//! Test Kubernetes module registration
+//!
+//! This script tests that the Kubernetes module is properly registered
+//! and available in the Rhai environment.
+
+print("=== Testing Kubernetes Module Registration ===");
+
+// Test that we can reference the kubernetes functions
+print("Testing function registration...");
+
+// These should not error even if we can't connect to a cluster
+let functions_to_test = [
+    "kubernetes_manager_new",
+    "pods_list",
+    "services_list", 
+    "deployments_list",
+    "delete",
+    "namespace_create",
+    "namespace_exists",
+    "resource_counts",
+    "pod_delete",
+    "service_delete",
+    "deployment_delete",
+    "namespace"
+];
+
+for func_name in functions_to_test {
+    print("✓ Function '" + func_name + "' is available");
+}
+
+print("\n=== All Kubernetes functions are properly registered! ===");
+print("Note: To test actual functionality, you need a running Kubernetes cluster.");
+print("See other examples in this directory for real cluster operations.");

examples/mycelium/mycelium_basic.rhai

@@ -0,0 +1,133 @@
+// Basic example of using the Mycelium client in Rhai
+
+// API URL for Mycelium
+let api_url = "http://localhost:8989";
+
+// Get node information
+print("Getting node information:");
+try {
+    let node_info = mycelium_get_node_info(api_url);
+    print(`Node subnet: ${node_info.nodeSubnet}`);
+    print(`Node public key: ${node_info.nodePubkey}`);
+} catch(err) {
+    print(`Error getting node info: ${err}`);
+}
+
+// List all peers
+print("\nListing all peers:");
+try {
+    let peers = mycelium_list_peers(api_url);
+    
+    if peers.is_empty() {
+        print("No peers connected.");
+    } else {
+        for peer in peers {
+            print(`Peer Endpoint: ${peer.endpoint.proto}://${peer.endpoint.socketAddr}`);
+            print(`  Type: ${peer.type}`);
+            print(`  Connection State: ${peer.connectionState}`);
+            print(`  Bytes sent: ${peer.txBytes}`);
+            print(`  Bytes received: ${peer.rxBytes}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing peers: ${err}`);
+}
+
+// Add a new peer
+print("\nAdding a new peer:");
+let new_peer_address = "tcp://65.21.231.58:9651";
+try {
+    let result = mycelium_add_peer(api_url, new_peer_address);
+    print(`Peer added: ${result.success}`);
+} catch(err) {
+    print(`Error adding peer: ${err}`);
+}
+
+// List selected routes
+print("\nListing selected routes:");
+try {
+    let routes = mycelium_list_selected_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No selected routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing routes: ${err}`);
+}
+
+// List fallback routes
+print("\nListing fallback routes:");
+try {
+    let routes = mycelium_list_fallback_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No fallback routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing fallback routes: ${err}`);
+}
+
+// Send a message
+// TO SEND A MESSAGE FILL IN THE DESTINATION IP ADDRESS
+// -----------------------------------------------------//
+// print("\nSending a message:");
+// let destination = < FILL IN CORRECT DEST IP >
+// let topic = "test";
+// let message = "Hello from Rhai!";
+// let deadline_secs = 60;
+
+// try {
+//     let result = mycelium_send_message(api_url, destination, topic, message, deadline_secs);
+//     print(`Message sent: ${result.success}`);
+//     if result.id {
+//         print(`Message ID: ${result.id}`);
+//     }
+// } catch(err) {
+//     print(`Error sending message: ${err}`);
+// }
+
+// Receive messages
+// RECEIVING MESSAGES SHOULD BE DONE ON THE DESTINATION NODE FROM THE CALL ABOVE
+// -----------------------------------------------------------------------------//
+// print("\nReceiving messages:");
+// let receive_topic = "test";
+// let count = 5;
+
+// try {
+//     let messages = mycelium_receive_messages(api_url, receive_topic, count);
+    
+//     if messages.is_empty() {
+//         print("No messages received.");
+//     } else {
+//         for msg in messages {
+//             print(`Message from: ${msg.source}`);
+//             print(`  Topic: ${msg.topic}`);
+//             print(`  Content: ${msg.content}`);
+//             print(`  Timestamp: ${msg.timestamp}`);
+//         }
+//     }
+// } catch(err) {
+//     print(`Error receiving messages: ${err}`);
+// }
+
+// Remove a peer
+print("\nRemoving a peer:");
+let peer_id = "tcp://65.21.231.58:9651"; // This is the peer we added earlier
+try {
+    let result = mycelium_remove_peer(api_url, peer_id);
+    print(`Peer removed: ${result.success}`);
+} catch(err) {
+    print(`Error removing peer: ${err}`);
+}

examples/mycelium/mycelium_receive_message.rhai

@@ -0,0 +1,31 @@
+// Script to receive Mycelium messages
+
+// API URL for Mycelium
+let api_url = "http://localhost:2222";
+
+// Receive messages
+// This script will listen for messages on a specific topic.
+// Ensure the sender script is using the same topic.
+// -----------------------------------------------------------------------------//
+print("\nReceiving messages:");
+let receive_topic = "test_topic";
+let wait_deadline_secs = 100; 
+
+print(`Listening for messages on topic '${receive_topic}'...`);
+try {
+    let messages = mycelium_receive_messages(api_url, receive_topic, wait_deadline_secs);
+    
+    if messages.is_empty() {
+        // print("No new messages received in this poll.");
+    } else {
+        print("Received a message:");
+        print(`  Message id: ${messages.id}`);
+        print(`  Message from: ${messages.srcIp}`);
+        print(`  Topic: ${messages.topic}`);
+        print(`  Payload: ${messages.payload}`);
+    }
+} catch(err) {
+    print(`Error receiving messages: ${err}`);
+}
+
+print("Finished attempting to receive messages.");

examples/mycelium/mycelium_send_message.rhai

@@ -0,0 +1,25 @@
+// Script to send a Mycelium message
+
+// API URL for Mycelium
+let api_url = "http://localhost:1111";
+
+// Send a message
+// TO SEND A MESSAGE FILL IN THE DESTINATION IP ADDRESS
+// -----------------------------------------------------//
+print("\nSending a message:");
+let destination = "50e:6d75:4568:366e:f75:2ac3:bbb1:3fdd"; // IMPORTANT: Replace with the actual destination IP address
+let topic = "test_topic";
+let message = "Hello from Rhai sender!";
+let deadline_secs = -10; // Seconds we wait for a reply
+
+try {
+    print(`Attempting to send message to ${destination} on topic '${topic}'`);
+    let result = mycelium_send_message(api_url, destination, topic, message, deadline_secs);
+    print(`result: ${result}`);
+    print(`Message sent: ${result.success}`);
+    if result.id != "" {
+        print(`Message ID: ${result.id}`);
+    }
+} catch(err) {
+    print(`Error sending message: ${err}`);
+}

examples/network/network_connectivity.rhai

@@ -0,0 +1,83 @@
+// Example of using the network modules in SAL
+// Shows TCP port checking, HTTP URL validation, and SSH command execution
+
+// Import system module for display
+import "os" as os;
+
+// Function to print section header
+fn section(title) {
+    print("\n");
+    print("==== " + title + " ====");
+    print("\n");
+}
+
+// TCP connectivity checks
+section("TCP Connectivity");
+
+// Create a TCP connector
+let tcp = sal::net::TcpConnector::new();
+
+// Check if a port is open
+let host = "localhost";
+let port = 22;
+print(`Checking if port ${port} is open on ${host}...`);
+let is_open = tcp.check_port(host, port);
+print(`Port ${port} is ${is_open ? "open" : "closed"}`);
+
+// Check multiple ports
+let ports = [22, 80, 443];
+print(`Checking multiple ports on ${host}...`);
+let port_results = tcp.check_ports(host, ports);
+for result in port_results {
+    print(`Port ${result.0} is ${result.1 ? "open" : "closed"}`);
+}
+
+// HTTP connectivity checks
+section("HTTP Connectivity");
+
+// Create an HTTP connector
+let http = sal::net::HttpConnector::new();
+
+// Check if a URL is reachable
+let url = "https://www.example.com";
+print(`Checking if ${url} is reachable...`);
+let is_reachable = http.check_url(url);
+print(`${url} is ${is_reachable ? "reachable" : "unreachable"}`);
+
+// Check the status code of a URL
+print(`Checking status code of ${url}...`);
+let status = http.check_status(url);
+if status {
+    print(`Status code: ${status.unwrap()}`);
+} else {
+    print("Failed to get status code");
+}
+
+// Only attempt SSH if port 22 is open
+if is_open {
+    // SSH connectivity checks
+    section("SSH Connectivity");
+    
+    // Create an SSH connection to localhost (if SSH server is running)
+    print("Attempting to connect to SSH server on localhost...");
+    
+    // Using the builder pattern
+    let ssh = sal::net::SshConnectionBuilder::new()
+        .host("localhost")
+        .port(22)
+        .user(os::get_env("USER") || "root")
+        .build();
+    
+    // Execute a simple command
+    print("Executing 'uname -a' command...");
+    let result = ssh.execute("uname -a");
+    if result.0 == 0 {
+        print("Command output:");
+        print(result.1);
+    } else {
+        print(`Command failed with exit code: ${result.0}`);
+        print(result.1);
+    }
+}
+
+print("\nNetwork connectivity checks completed.");

examples/network/network_rhai.rhai

@@ -0,0 +1,83 @@
+// Example of using the network modules in SAL through Rhai
+// Shows TCP port checking, HTTP URL validation, and SSH command execution
+
+
+// Function to print section header
+fn section(title) {
+    print("\n");
+    print("==== " + title + " ====");
+    print("\n");
+}
+
+// TCP connectivity checks
+section("TCP Connectivity");
+
+// Create a TCP connector
+let tcp = net::new_tcp_connector();
+
+// Check if a port is open
+let host = "localhost";
+let port = 22;
+print(`Checking if port ${port} is open on ${host}...`);
+let is_open = tcp.check_port(host, port);
+print(`Port ${port} is ${if is_open { "open" } else { "closed" }}`);
+
+// Check multiple ports
+let ports = [22, 80, 443];
+print(`Checking multiple ports on ${host}...`);
+let port_results = tcp.check_ports(host, ports);
+for result in port_results {
+    print(`Port ${result.port} is ${if result.is_open { "open" } else { "closed" }}`);
+}
+
+// HTTP connectivity checks
+section("HTTP Connectivity");
+
+// Create an HTTP connector
+let http = net::new_http_connector();
+
+// Check if a URL is reachable
+let url = "https://www.example.com";
+print(`Checking if ${url} is reachable...`);
+let is_reachable = http.check_url(url);
+print(`${url} is ${if is_reachable { "reachable" } else { "unreachable" }}`);
+
+// Check the status code of a URL
+print(`Checking status code of ${url}...`);
+let status = http.check_status(url);
+if status != () {
+    print(`Status code: ${status}`);
+} else {
+    print("Failed to get status code");
+}
+
+// Get content from a URL
+print(`Getting content from ${url}...`);
+let content = http.get_content(url);
+print(`Content length: ${content.len()} characters`);
+print(`First 100 characters: ${content.substr(0, 100)}...`);
+
+// Only attempt SSH if port 22 is open
+if is_open {
+    // SSH connectivity checks
+    section("SSH Connectivity");
+    
+    // Create an SSH connection to localhost (if SSH server is running)
+    print("Attempting to connect to SSH server on localhost...");
+    
+    // Using the builder pattern
+    let ssh = net::new_ssh_builder()
+        .host("localhost")
+        .port(22)
+        .user(if os::get_env("USER") != () { os::get_env("USER") } else { "root" })
+        .timeout(10)
+        .build();
+    
+    // Execute a simple command
+    print("Executing 'uname -a' command...");
+    let result = ssh.execute("uname -a");
+    print(`Command exit code: ${result.code}`);
+    print(`Command output: ${result.output}`);
+}
+
+print("\nNetwork connectivity checks completed.");

examples/process/run_basic.rhai

@@ -1,7 +1,7 @@
-print("Running a basic command using run().do()...");
+print("Running a basic command using run().execute()...");
 
 // Execute a simple command
-let result = run("echo Hello from run_basic!").do();
+let result = run("echo Hello from run_basic!").execute();
 
 // Print the command result
 print(`Command: echo Hello from run_basic!`);
@@ -13,6 +13,6 @@ print(`Stderr:\n${result.stderr}`);
 // Example of a command that might fail (if 'nonexistent_command' doesn't exist)
 // This will halt execution by default because ignore_error() is not used.
 // print("Running a command that will fail (and should halt)...");
-// let fail_result = run("nonexistent_command").do(); // This line will cause the script to halt if the command doesn't exist
+// let fail_result = run("nonexistent_command").execute(); // This line will cause the script to halt if the command doesn't exist
 
 print("Basic run() example finished.");

examples/process/run_ignore_error.rhai

@@ -2,7 +2,7 @@ print("Running a command that will fail, but ignoring the error...");
 
 // Run a command that exits with a non-zero code (will fail)
 // Using .ignore_error() prevents the script from halting
-let result = run("exit 1").ignore_error().do();
+let result = run("exit 1").ignore_error().execute();
 
 print(`Command finished.`);
 print(`Success: ${result.success}`); // This should be false
@@ -22,7 +22,7 @@ print("\nScript continued execution after the potentially failing command.");
 // Example of a command that might fail due to OS error (e.g., command not found)
 // This *might* still halt depending on how the underlying Rust function handles it,
 // as ignore_error() primarily prevents halting on *command* non-zero exit codes.
-// let os_error_result = run("nonexistent_command_123").ignore_error().do();
+// let os_error_result = run("nonexistent_command_123").ignore_error().execute();
 // print(`OS Error Command Success: ${os_error_result.success}`);
 // print(`OS Error Command Exit Code: ${os_error_result.code}`);
 

examples/process/run_log.rhai

@@ -1,8 +1,8 @@
-print("Running a command using run().log().do()...");
+print("Running a command using run().log().execute()...");
 
 // The .log() method will print the command string to the console before execution.
 // This is useful for debugging or tracing which commands are being run.
-let result = run("echo This command is logged").log().do();
+let result = run("echo This command is logged").log().execute();
 
 print(`Command finished.`);
 print(`Success: ${result.success}`);

examples/process/run_silent.rhai

@@ -1,8 +1,8 @@
-print("Running a command using run().silent().do()...\n");
+print("Running a command using run().silent().execute()...\n");
 
 // This command will print to standard output and standard error
 // However, because .silent() is used, the output will not appear in the console directly
-let result = run("echo 'This should be silent stdout.'; echo 'This should be silent stderr.' >&2; exit 0").silent().do();
+let result = run("echo 'This should be silent stdout.'; echo 'This should be silent stderr.' >&2; exit 0").silent().execute();
 
 // The output is still captured in the CommandResult
 print(`Command finished.`);
@@ -12,7 +12,7 @@ print(`Captured Stdout:\\n${result.stdout}`);
 print(`Captured Stderr:\\n${result.stderr}`);
 
 // Example of a silent command that fails (but won't halt because we only suppress output)
-// let fail_result = run("echo 'This is silent failure stderr.' >&2; exit 1").silent().do();
+// let fail_result = run("echo 'This is silent failure stderr.' >&2; exit 1").silent().execute();
 // print(`Failed command finished (silent):`);
 // print(`Success: ${fail_result.success}`);
 // print(`Exit Code: ${fail_result.code}`);

examples/service_manager/README.md

@@ -0,0 +1,116 @@
+# Service Manager Examples
+
+This directory contains examples demonstrating the SAL service manager functionality for dynamically launching and managing services across platforms.
+
+## Overview
+
+The service manager provides a unified interface for managing system services:
+- **macOS**: Uses `launchctl` for service management
+- **Linux**: Uses `zinit` for service management (systemd also available as alternative)
+
+## Examples
+
+### 1. Circle Worker Manager (`circle_worker_manager.rhai`)
+
+**Primary Use Case**: Demonstrates dynamic circle worker management for freezone residents.
+
+This example shows:
+- Creating service configurations for circle workers
+- Complete service lifecycle management (start, stop, restart, remove)
+- Status monitoring and log retrieval
+- Error handling and cleanup
+
+```bash
+# Run the circle worker management example
+herodo examples/service_manager/circle_worker_manager.rhai
+```
+
+### 2. Basic Usage (`basic_usage.rhai`)
+
+**Learning Example**: Simple demonstration of the core service manager API.
+
+This example covers:
+- Creating and configuring services
+- Starting and stopping services
+- Checking service status
+- Listing managed services
+- Retrieving service logs
+
+```bash
+# Run the basic usage example
+herodo examples/service_manager/basic_usage.rhai
+```
+
+## Prerequisites
+
+### Linux (zinit)
+
+Make sure zinit is installed and running:
+
+```bash
+# Start zinit with default socket
+zinit -s /tmp/zinit.sock init
+```
+
+### macOS (launchctl)
+
+No additional setup required - uses the built-in launchctl system.
+
+## Service Manager API
+
+The service manager provides these key functions:
+
+- `create_service_manager()` - Create platform-appropriate service manager
+- `start(manager, config)` - Start a new service
+- `stop(manager, service_name)` - Stop a running service
+- `restart(manager, service_name)` - Restart a service
+- `status(manager, service_name)` - Get service status
+- `logs(manager, service_name, lines)` - Retrieve service logs
+- `list(manager)` - List all managed services
+- `remove(manager, service_name)` - Remove a service
+- `exists(manager, service_name)` - Check if service exists
+- `start_and_confirm(manager, config, timeout)` - Start with confirmation
+
+## Service Configuration
+
+Services are configured using a map with these fields:
+
+```rhai
+let config = #{
+    name: "my-service",                    // Service name
+    binary_path: "/usr/bin/my-app",        // Executable path
+    args: ["--config", "/etc/my-app.conf"], // Command arguments
+    working_directory: "/var/lib/my-app",   // Working directory (optional)
+    environment: #{                         // Environment variables
+        "VAR1": "value1",
+        "VAR2": "value2"
+    },
+    auto_restart: true                      // Auto-restart on failure
+};
+```
+
+## Real-World Usage
+
+The circle worker example demonstrates the exact use case requested by the team:
+
+> "We want to be able to launch circle workers dynamically. For instance when someone registers to the freezone, we need to be able to launch a circle worker for the new resident."
+
+The service manager enables:
+1. **Dynamic service creation** - Create services on-demand for new residents
+2. **Cross-platform support** - Works on both macOS and Linux
+3. **Lifecycle management** - Full control over service lifecycle
+4. **Monitoring and logging** - Track service status and retrieve logs
+5. **Cleanup** - Proper service removal when no longer needed
+
+## Error Handling
+
+All service manager functions can throw errors. Use try-catch blocks for robust error handling:
+
+```rhai
+try {
+    sm::start(manager, config);
+    print("✅ Service started successfully");
+} catch (error) {
+    print(`❌ Failed to start service: ${error}`);
+}
+```

examples/service_manager/basic_usage.rhai

@@ -0,0 +1,85 @@
+// Basic Service Manager Usage Example
+//
+// This example demonstrates the basic API of the service manager.
+// It works on both macOS (launchctl) and Linux (zinit/systemd).
+//
+// Prerequisites:
+//
+// Linux: The service manager will automatically discover running zinit servers
+//        or fall back to systemd. To use zinit, start it with:
+//   zinit -s /tmp/zinit.sock init
+//
+//   You can also specify a custom socket path:
+//   export ZINIT_SOCKET_PATH=/your/custom/path/zinit.sock
+//
+// macOS: No additional setup required (uses launchctl).
+//
+// Usage:
+//   herodo examples/service_manager/basic_usage.rhai
+
+// Service Manager Basic Usage Example
+// This example uses the SAL service manager through Rhai integration
+
+print("🚀 Basic Service Manager Usage Example");
+print("======================================");
+
+// Create a service manager for the current platform
+let manager = create_service_manager();
+
+print("🍎 Using service manager for current platform");
+
+// Create a simple service configuration
+let config = #{
+    name: "example-service",
+    binary_path: "/bin/echo",
+    args: ["Hello from service manager!"],
+    working_directory: "/tmp",
+    environment: #{
+        "EXAMPLE_VAR": "hello_world"
+    },
+    auto_restart: false
+};
+
+print("\n📝 Service Configuration:");
+print(`   Name: ${config.name}`);
+print(`   Binary: ${config.binary_path}`);
+print(`   Args: ${config.args}`);
+
+// Start the service
+print("\n🚀 Starting service...");
+start(manager, config);
+print("✅ Service started successfully");
+
+// Check service status
+print("\n📊 Checking service status...");
+let status = status(manager, "example-service");
+print(`Status: ${status}`);
+
+// List all services
+print("\n📋 Listing all managed services...");
+let services = list(manager);
+print(`Found ${services.len()} services:`);
+for service in services {
+    print(`  - ${service}`);
+}
+
+// Get service logs
+print("\n📄 Getting service logs...");
+let logs = logs(manager, "example-service", 5);
+if logs.trim() == "" {
+    print("No logs available");
+} else {
+    print(`Logs:\n${logs}`);
+}
+
+// Stop the service
+print("\n🛑 Stopping service...");
+stop(manager, "example-service");
+print("✅ Service stopped");
+
+// Remove the service
+print("\n🗑️  Removing service...");
+remove(manager, "example-service");
+print("✅ Service removed");
+
+print("\n🎉 Example completed successfully!");

examples/service_manager/circle_worker_manager.rhai

@@ -0,0 +1,141 @@
+// Circle Worker Manager Example
+//
+// This example demonstrates how to use the service manager to dynamically launch
+// circle workers for new freezone residents. This is the primary use case requested
+// by the team.
+//
+// Usage:
+//
+// On macOS (uses launchctl):
+//   herodo examples/service_manager/circle_worker_manager.rhai
+//
+// On Linux (uses zinit - requires zinit to be running):
+//   First start zinit: zinit -s /tmp/zinit.sock init
+//   herodo examples/service_manager/circle_worker_manager.rhai
+
+// Circle Worker Manager Example
+// This example uses the SAL service manager through Rhai integration
+
+print("🚀 Circle Worker Manager Example");
+print("=================================");
+
+// Create the appropriate service manager for the current platform
+let service_manager = create_service_manager();
+print("✅ Created service manager for current platform");
+
+// Simulate a new freezone resident registration
+let resident_id = "resident_12345";
+let worker_name = `circle-worker-${resident_id}`;
+
+print(`\n📝 New freezone resident registered: ${resident_id}`);
+print(`🔧 Creating circle worker service: ${worker_name}`);
+
+// Create service configuration for the circle worker
+let config = #{
+    name: worker_name,
+    binary_path: "/bin/sh",
+    args: [
+        "-c",
+        `echo 'Circle worker for ${resident_id} starting...'; sleep 30; echo 'Circle worker for ${resident_id} completed'`
+    ],
+    working_directory: "/tmp",
+    environment: #{
+        "RESIDENT_ID": resident_id,
+        "WORKER_TYPE": "circle",
+        "LOG_LEVEL": "info"
+    },
+    auto_restart: true
+};
+
+print("📋 Service configuration created:");
+print(`   Name: ${config.name}`);
+print(`   Binary: ${config.binary_path}`);
+print(`   Args: ${config.args}`);
+print(`   Auto-restart: ${config.auto_restart}`);
+
+print(`\n🔄 Demonstrating service lifecycle for: ${worker_name}`);
+
+// 1. Check if service already exists
+print("\n1️⃣ Checking if service exists...");
+if exists(service_manager, worker_name) {
+    print("⚠️  Service already exists, removing it first...");
+    remove(service_manager, worker_name);
+    print("🗑️  Existing service removed");
+} else {
+    print("✅ Service doesn't exist, ready to create");
+}
+
+// 2. Start the service
+print("\n2️⃣ Starting the circle worker service...");
+start(service_manager, config);
+print("✅ Service started successfully");
+
+// 3. Check service status
+print("\n3️⃣ Checking service status...");
+let status = status(service_manager, worker_name);
+print(`📊 Service status: ${status}`);
+
+// 4. List all services to show our service is there
+print("\n4️⃣ Listing all managed services...");
+let services = list(service_manager);
+print(`📋 Managed services (${services.len()}):`);
+for service in services {
+    let marker = if service == worker_name { "👉" } else { "  " };
+    print(`   ${marker} ${service}`);
+}
+
+// 5. Wait a moment and check status again
+print("\n5️⃣ Waiting 3 seconds and checking status again...");
+sleep(3000); // 3 seconds in milliseconds
+let status = status(service_manager, worker_name);
+print(`📊 Service status after 3s: ${status}`);
+
+// 6. Get service logs
+print("\n6️⃣ Retrieving service logs...");
+let logs = logs(service_manager, worker_name, 10);
+if logs.trim() == "" {
+    print("📄 No logs available yet (this is normal for new services)");
+} else {
+    print("📄 Recent logs:");
+    let log_lines = logs.split('\n');
+    for i in 0..5 {
+        if i < log_lines.len() {
+            print(`   ${log_lines[i]}`);
+        }
+    }
+}
+
+// 7. Demonstrate start_and_confirm with timeout
+print("\n7️⃣ Testing start_and_confirm (should succeed quickly since already running)...");
+start_and_confirm(service_manager, config, 5);
+print("✅ Service confirmed running within timeout");
+
+// 8. Stop the service
+print("\n8️⃣ Stopping the service...");
+stop(service_manager, worker_name);
+print("🛑 Service stopped");
+
+// 9. Check status after stopping
+print("\n9️⃣ Checking status after stop...");
+let status = status(service_manager, worker_name);
+print(`📊 Service status after stop: ${status}`);
+
+// 10. Restart the service
+print("\n🔟 Restarting the service...");
+restart(service_manager, worker_name);
+print("🔄 Service restarted successfully");
+
+// 11. Final cleanup
+print("\n🧹 Cleaning up - removing the service...");
+remove(service_manager, worker_name);
+print("🗑️  Service removed successfully");
+
+// 12. Verify removal
+print("\n✅ Verifying service removal...");
+if !exists(service_manager, worker_name) {
+    print("✅ Service successfully removed");
+} else {
+    print("⚠️  Service still exists after removal");
+}
+
+print("\n🎉 Circle worker management demonstration complete!");

examples/zinit/zinit_basic.rhai

@@ -1,7 +1,7 @@
 // Basic example of using the Zinit client in Rhai
 
 // Socket path for Zinit
-let socket_path = "/var/run/zinit.sock";
+let socket_path = "/tmp/zinit.sock";
 
 // List all services
 print("Listing all services:");
@@ -63,15 +63,6 @@ try {
     for log in logs {
         print(log);
     }
-
-    // Or to get all logs (uncomment if needed)
-    // print("\nGetting all logs:");
-    // let all_logs = zinit_logs_all(socket_path);
-    // 
-    // for log in all_logs {
-    //     print(log);
-    // }
-    
     // Clean up
     print("\nCleaning up:");
     let stop_result = zinit_stop(socket_path, new_service);

examples/zinit/zinit_basic2.rhai

@@ -0,0 +1,41 @@
+// Basic example of using the Zinit client in Rhai
+
+// Socket path for Zinit
+let socket_path = "/tmp/zinit.sock";
+
+// Create a new service
+print("\nCreating a new service:");
+let new_service = "rhai-test-service";
+let exec_command = "echo 'Hello from Rhai'";
+let oneshot = true;
+
+let result = zinit_create_service(socket_path, new_service, exec_command, oneshot);
+print(`Service created: ${result}`);
+
+// Monitor the service
+print("\nMonitoring the service:");
+let monitor_result = zinit_monitor(socket_path, new_service);
+print(`Service monitored: ${monitor_result}`);
+
+// Start the service
+print("\nStarting the service:");
+let start_result = zinit_start(socket_path, new_service);
+print(`Service started: ${start_result}`);
+
+// Get logs for a specific service
+print("\nGetting logs:");
+let logs = zinit_logs(socket_path, new_service);
+
+for log in logs {
+    print(log);
+}
+// Clean up
+print("\nCleaning up:");
+let stop_result = zinit_stop(socket_path, new_service);
+print(`Service stopped: ${stop_result}`);
+
+let forget_result = zinit_forget(socket_path, new_service);
+print(`Service forgotten: ${forget_result}`);
+
+let delete_result = zinit_delete_service(socket_path, new_service);
+print(`Service deleted: ${delete_result}`);

herodo/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "herodo"
+version = "0.1.0"
+edition = "2021"
+authors = ["PlanetFirst <info@incubaid.com>"]
+description = "Herodo - A Rhai script executor for SAL (System Abstraction Layer)"
+repository = "https://git.threefold.info/herocode/sal"
+license = "Apache-2.0"
+keywords = ["rhai", "scripting", "automation", "sal", "system"]
+categories = ["command-line-utilities", "development-tools"]
+
+[[bin]]
+name = "herodo"
+path = "src/main.rs"
+
+[dependencies]
+# Core dependencies for herodo binary
+env_logger = { workspace = true }
+rhai = { workspace = true }
+
+# SAL library for Rhai module registration (with all features for herodo)
+sal = { path = "..", features = ["all"] }
+
+[dev-dependencies]
+tempfile = { workspace = true }

herodo/README.md

@@ -0,0 +1,160 @@
+# Herodo - Rhai Script Executor for SAL
+
+**Version: 0.1.0**
+
+Herodo is a command-line utility that executes Rhai scripts with full access to the SAL (System Abstraction Layer) library. It provides a powerful scripting environment for automation and system management tasks.
+
+## Features
+
+- **Single Script Execution**: Execute individual `.rhai` script files
+- **Directory Execution**: Execute all `.rhai` scripts in a directory (recursively)
+- **Sorted Execution**: Scripts are executed in alphabetical order for predictable behavior
+- **SAL Integration**: Full access to all SAL modules and functions
+- **Error Handling**: Clear error messages and proper exit codes
+- **Logging Support**: Built-in logging with `env_logger`
+
+## Installation
+
+### Build and Install
+
+```bash
+git clone https://github.com/PlanetFirst/sal.git
+cd sal
+./build_herodo.sh
+```
+
+This script will:
+- Build herodo in debug mode
+- Install it to `~/hero/bin/herodo` (non-root) or `/usr/local/bin/herodo` (root)
+- Make it available in your PATH
+
+**Note**: If using the non-root installation, make sure `~/hero/bin` is in your PATH:
+```bash
+export PATH="$HOME/hero/bin:$PATH"
+```
+
+### Install from crates.io (Coming Soon)
+
+```bash
+# This will be available once herodo is published to crates.io
+cargo install herodo
+```
+
+**Note**: `herodo` is not yet published to crates.io due to publishing rate limits. It will be available soon.
+
+## Usage
+
+### Execute a Single Script
+
+```bash
+herodo path/to/script.rhai
+```
+
+### Execute All Scripts in a Directory
+
+```bash
+herodo path/to/scripts/
+```
+
+When given a directory, herodo will:
+1. Recursively find all `.rhai` files
+2. Sort them alphabetically
+3. Execute them in order
+4. Stop on the first error
+
+## Example Scripts
+
+### Basic Script
+```rhai
+// hello.rhai
+println("Hello from Herodo!");
+let result = 42 * 2;
+println("Result: " + result);
+```
+
+### Using SAL Functions
+```rhai
+// system_info.rhai
+println("=== System Information ===");
+
+// Check if a file exists
+let config_exists = exist("/etc/hosts");
+println("Config file exists: " + config_exists);
+
+// Download a file
+download("https://example.com/data.txt", "/tmp/data.txt");
+println("File downloaded successfully");
+
+// Execute a system command
+let output = run("ls -la /tmp");
+println("Directory listing:");
+println(output.stdout);
+```
+
+### Redis Operations
+```rhai
+// redis_example.rhai
+println("=== Redis Operations ===");
+
+// Set a value
+redis_set("app_status", "running");
+println("Status set in Redis");
+
+// Get the value
+let status = redis_get("app_status");
+println("Current status: " + status);
+```
+
+## Available SAL Functions
+
+Herodo provides access to all SAL modules through Rhai:
+
+- **File System**: `exist()`, `mkdir()`, `delete()`, `file_size()`
+- **Downloads**: `download()`, `download_install()`
+- **Process Management**: `run()`, `kill()`, `process_list()`
+- **Redis**: `redis_set()`, `redis_get()`, `redis_del()`
+- **PostgreSQL**: Database operations and management
+- **Network**: HTTP requests, SSH operations, TCP connectivity
+- **Virtualization**: Container operations with Buildah and Nerdctl
+- **Text Processing**: String manipulation and template rendering
+- **And many more...**
+
+## Error Handling
+
+Herodo provides clear error messages and appropriate exit codes:
+
+- **Exit Code 0**: All scripts executed successfully
+- **Exit Code 1**: Error occurred (file not found, script error, etc.)
+
+## Logging
+
+Enable detailed logging by setting the `RUST_LOG` environment variable:
+
+```bash
+RUST_LOG=debug herodo script.rhai
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+cd herodo
+cargo test
+```
+
+The test suite includes:
+- Unit tests for core functionality
+- Integration tests with real script execution
+- Error handling scenarios
+- SAL module integration tests
+
+## Dependencies
+
+- **rhai**: Embedded scripting language
+- **env_logger**: Logging implementation  
+- **sal**: System Abstraction Layer library
+
+## License
+
+Apache-2.0

herodo/src/lib.rs

@@ -0,0 +1,143 @@
+//! Herodo - A Rhai script executor for SAL
+//!
+//! This library loads the Rhai engine, registers all SAL modules,
+//! and executes Rhai scripts from a specified directory in sorted order.
+
+use rhai::{Engine, Scope};
+use std::error::Error;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process;
+
+/// Run the herodo script executor with the given script path
+///
+/// # Arguments
+///
+/// * `script_path` - Path to a Rhai script file or directory containing Rhai scripts
+///
+/// # Returns
+///
+/// Result indicating success or failure
+pub fn run(script_path: &str) -> Result<(), Box<dyn Error>> {
+    let path = Path::new(script_path);
+
+    // Check if the path exists
+    if !path.exists() {
+        eprintln!("Error: '{}' does not exist", script_path);
+        process::exit(1);
+    }
+
+    // Create a new Rhai engine
+    let mut engine = Engine::new();
+    
+    // TODO: if we create a scope here we could clean up all the different functionsand types regsitered wit the engine
+    // We should generalize the way we add things to the scope for each module sepeartely
+    let mut scope = Scope::new();
+    // Conditionally add Hetzner client only when env config is present
+    if let Ok(cfg) = sal::hetzner::config::Config::from_env() {
+        let hetzner_client = sal::hetzner::api::Client::new(cfg);
+        scope.push("hetzner", hetzner_client);
+    }
+    // This makes it easy to call e.g. `hetzner.get_server()` or `mycelium.get_connected_peers()`
+    // --> without the need of manually created a client for each one first
+    // --> could be conditionally compiled to only use those who we need (we only push the things to the scope that we actually need to run the script)
+
+
+    // Register println function for output
+    engine.register_fn("println", |s: &str| println!("{}", s));
+
+    // Register all SAL modules with the engine
+    sal::rhai::register(&mut engine)?;
+
+    // Collect script files to execute
+    let script_files: Vec<PathBuf> = if path.is_file() {
+        // Single file
+        if let Some(extension) = path.extension() {
+            if extension != "rhai" {
+                eprintln!("Warning: '{}' does not have a .rhai extension", script_path);
+            }
+        }
+        vec![path.to_path_buf()]
+    } else if path.is_dir() {
+        // Directory - collect all .rhai files recursively and sort them
+        let mut files = Vec::new();
+        collect_rhai_files(path, &mut files)?;
+
+        if files.is_empty() {
+            eprintln!("No .rhai files found in directory: {}", script_path);
+            process::exit(1);
+        }
+
+        // Sort files for consistent execution order
+        files.sort();
+
+        files
+    } else {
+        eprintln!("Error: '{}' is neither a file nor a directory", script_path);
+        process::exit(1);
+    };
+
+    println!(
+        "Found {} Rhai script{} to execute:",
+        script_files.len(),
+        if script_files.len() == 1 { "" } else { "s" }
+    );
+
+    // Execute each script in sorted order
+    for script_file in script_files {
+        println!("\nExecuting: {}", script_file.display());
+
+        // Read the script content
+        let script = fs::read_to_string(&script_file)?;
+
+        // Execute the script
+        // match engine.eval::<rhai::Dynamic>(&script) {
+        //     Ok(result) => {
+        //         println!("Script executed successfully");
+        //         if !result.is_unit() {
+        //             println!("Result: {}", result);
+        //         }
+        //     }
+        //     Err(err) => {
+        //         eprintln!("Error executing script: {}", err);
+        //         // Exit with error code when a script fails
+        //         process::exit(1);
+        //     }
+        // }
+        engine.run_with_scope(&mut scope, &script)?;
+    }
+
+    println!("\nAll scripts executed successfully!");
+    Ok(())
+}
+
+/// Recursively collect all .rhai files from a directory
+///
+/// # Arguments
+///
+/// * `dir` - Directory to search
+/// * `files` - Vector to collect files into
+///
+/// # Returns
+///
+/// Result indicating success or failure
+fn collect_rhai_files(dir: &Path, files: &mut Vec<PathBuf>) -> Result<(), Box<dyn Error>> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.is_dir() {
+            // Recursively search subdirectories
+            collect_rhai_files(&path, files)?;
+        } else if path.is_file() {
+            // Check if it's a .rhai file
+            if let Some(extension) = path.extension() {
+                if extension == "rhai" {
+                    files.push(path);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

herodo/src/main.rs

@@ -0,0 +1,25 @@
+//! Herodo binary entry point
+//!
+//! This is the main entry point for the herodo binary.
+//! It parses command line arguments and executes Rhai scripts using the SAL library.
+
+use env_logger;
+use std::env;
+use std::process;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize the logger
+    env_logger::init();
+
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() != 2 {
+        eprintln!("Usage: {} <script_path>", args[0]);
+        process::exit(1);
+    }
+
+    let script_path = &args[1];
+
+    // Call the run function from the herodo library
+    herodo::run(script_path)
+}

herodo/tests/integration_tests.rs

@@ -0,0 +1,222 @@
+//! Integration tests for herodo script executor
+//!
+//! These tests verify that herodo can execute Rhai scripts correctly,
+//! handle errors appropriately, and integrate with SAL modules.
+
+use std::fs;
+use std::path::Path;
+use tempfile::TempDir;
+
+/// Test that herodo can execute a simple Rhai script
+#[test]
+fn test_simple_script_execution() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let script_path = temp_dir.path().join("test.rhai");
+
+    // Create a simple test script
+    fs::write(
+        &script_path,
+        r#"
+        println("Hello from herodo test!");
+        let result = 42;
+        result
+    "#,
+    )
+    .expect("Failed to write test script");
+
+    // Execute the script
+    let result = herodo::run(script_path.to_str().unwrap());
+    assert!(result.is_ok(), "Script execution should succeed");
+}
+
+/// Test that herodo can execute multiple scripts in a directory
+#[test]
+fn test_directory_script_execution() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create multiple test scripts
+    fs::write(
+        temp_dir.path().join("01_first.rhai"),
+        r#"
+        println("First script executing");
+        let first = 1;
+    "#,
+    )
+    .expect("Failed to write first script");
+
+    fs::write(
+        temp_dir.path().join("02_second.rhai"),
+        r#"
+        println("Second script executing");
+        let second = 2;
+    "#,
+    )
+    .expect("Failed to write second script");
+
+    fs::write(
+        temp_dir.path().join("03_third.rhai"),
+        r#"
+        println("Third script executing");
+        let third = 3;
+    "#,
+    )
+    .expect("Failed to write third script");
+
+    // Execute all scripts in the directory
+    let result = herodo::run(temp_dir.path().to_str().unwrap());
+    assert!(result.is_ok(), "Directory script execution should succeed");
+}
+
+/// Test that herodo handles non-existent paths correctly
+#[test]
+fn test_nonexistent_path_handling() {
+    // This test verifies error handling but herodo::run calls process::exit
+    // In a real scenario, we would need to refactor herodo to return errors
+    // instead of calling process::exit for better testability
+
+    // For now, we test that the path validation logic works
+    let nonexistent_path = "/this/path/does/not/exist";
+    let path = Path::new(nonexistent_path);
+    assert!(!path.exists(), "Test path should not exist");
+}
+
+/// Test that herodo can execute scripts with SAL module functions
+#[test]
+fn test_sal_module_integration() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let script_path = temp_dir.path().join("sal_test.rhai");
+
+    // Create a script that uses SAL functions
+    fs::write(
+        &script_path,
+        r#"
+        println("Testing SAL module integration");
+        
+        // Test file existence check (should work with temp directory)
+        let temp_exists = exist(".");
+        println("Current directory exists: " + temp_exists);
+        
+        // Test basic text operations
+        let text = "  hello world  ";
+        let trimmed = text.trim();
+        println("Trimmed text: '" + trimmed + "'");
+        
+        println("SAL integration test completed");
+    "#,
+    )
+    .expect("Failed to write SAL test script");
+
+    // Execute the script
+    let result = herodo::run(script_path.to_str().unwrap());
+    assert!(
+        result.is_ok(),
+        "SAL integration script should execute successfully"
+    );
+}
+
+/// Test script execution with subdirectories
+#[test]
+fn test_recursive_directory_execution() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create subdirectory
+    let sub_dir = temp_dir.path().join("subdir");
+    fs::create_dir(&sub_dir).expect("Failed to create subdirectory");
+
+    // Create scripts in main directory
+    fs::write(
+        temp_dir.path().join("main.rhai"),
+        r#"
+        println("Main directory script");
+    "#,
+    )
+    .expect("Failed to write main script");
+
+    // Create scripts in subdirectory
+    fs::write(
+        sub_dir.join("sub.rhai"),
+        r#"
+        println("Subdirectory script");
+    "#,
+    )
+    .expect("Failed to write sub script");
+
+    // Execute all scripts recursively
+    let result = herodo::run(temp_dir.path().to_str().unwrap());
+    assert!(
+        result.is_ok(),
+        "Recursive directory execution should succeed"
+    );
+}
+
+/// Test that herodo handles empty directories gracefully
+#[test]
+fn test_empty_directory_handling() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create an empty subdirectory
+    let empty_dir = temp_dir.path().join("empty");
+    fs::create_dir(&empty_dir).expect("Failed to create empty directory");
+
+    // This should handle the empty directory case
+    // Note: herodo::run will call process::exit(1) for empty directories
+    // In a production refactor, this should return an error instead
+    let path = empty_dir.to_str().unwrap();
+    let path_obj = Path::new(path);
+    assert!(
+        path_obj.is_dir(),
+        "Empty directory should exist and be a directory"
+    );
+}
+
+/// Test script with syntax errors
+#[test]
+fn test_syntax_error_handling() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let script_path = temp_dir.path().join("syntax_error.rhai");
+
+    // Create a script with syntax errors
+    fs::write(
+        &script_path,
+        r#"
+        println("This script has syntax errors");
+        let invalid syntax here;
+        missing_function_call(;
+    "#,
+    )
+    .expect("Failed to write syntax error script");
+
+    // Note: herodo::run will call process::exit(1) on script errors
+    // In a production refactor, this should return an error instead
+    // For now, we just verify the file exists and can be read
+    assert!(script_path.exists(), "Syntax error script should exist");
+    let content = fs::read_to_string(&script_path).expect("Should be able to read script");
+    assert!(
+        content.contains("syntax errors"),
+        "Script should contain expected content"
+    );
+}
+
+/// Test file extension validation
+#[test]
+fn test_file_extension_validation() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create files with different extensions
+    let rhai_file = temp_dir.path().join("valid.rhai");
+    let txt_file = temp_dir.path().join("invalid.txt");
+
+    fs::write(&rhai_file, "println(\"Valid rhai file\");").expect("Failed to write rhai file");
+    fs::write(&txt_file, "This is not a rhai file").expect("Failed to write txt file");
+
+    // Verify file extensions
+    assert_eq!(rhai_file.extension().unwrap(), "rhai");
+    assert_eq!(txt_file.extension().unwrap(), "txt");
+
+    // herodo should execute .rhai files and warn about non-.rhai files
+    let result = herodo::run(rhai_file.to_str().unwrap());
+    assert!(
+        result.is_ok(),
+        "Valid .rhai file should execute successfully"
+    );
+}

herodo/tests/unit_tests.rs

@@ -0,0 +1,268 @@
+//! Unit tests for herodo library functions
+//!
+//! These tests focus on individual functions and components of the herodo library.
+
+use std::fs;
+use tempfile::TempDir;
+
+/// Test the collect_rhai_files function indirectly through directory operations
+#[test]
+fn test_rhai_file_collection_logic() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create various files
+    fs::write(temp_dir.path().join("script1.rhai"), "// Script 1")
+        .expect("Failed to write script1");
+    fs::write(temp_dir.path().join("script2.rhai"), "// Script 2")
+        .expect("Failed to write script2");
+    fs::write(temp_dir.path().join("not_script.txt"), "Not a script")
+        .expect("Failed to write txt file");
+    fs::write(temp_dir.path().join("README.md"), "# README").expect("Failed to write README");
+
+    // Create subdirectory with more scripts
+    let sub_dir = temp_dir.path().join("subdir");
+    fs::create_dir(&sub_dir).expect("Failed to create subdirectory");
+    fs::write(sub_dir.join("sub_script.rhai"), "// Sub script")
+        .expect("Failed to write sub script");
+
+    // Count .rhai files manually
+    let mut rhai_count = 0;
+    for entry in fs::read_dir(temp_dir.path()).expect("Failed to read temp directory") {
+        let entry = entry.expect("Failed to get directory entry");
+        let path = entry.path();
+        if path.is_file() && path.extension().map_or(false, |ext| ext == "rhai") {
+            rhai_count += 1;
+        }
+    }
+
+    // Should find 2 .rhai files in the main directory
+    assert_eq!(
+        rhai_count, 2,
+        "Should find exactly 2 .rhai files in main directory"
+    );
+
+    // Verify subdirectory has 1 .rhai file
+    let mut sub_rhai_count = 0;
+    for entry in fs::read_dir(&sub_dir).expect("Failed to read subdirectory") {
+        let entry = entry.expect("Failed to get directory entry");
+        let path = entry.path();
+        if path.is_file() && path.extension().map_or(false, |ext| ext == "rhai") {
+            sub_rhai_count += 1;
+        }
+    }
+
+    assert_eq!(
+        sub_rhai_count, 1,
+        "Should find exactly 1 .rhai file in subdirectory"
+    );
+}
+
+/// Test path validation logic
+#[test]
+fn test_path_validation() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let script_path = temp_dir.path().join("test.rhai");
+
+    // Create a test script
+    fs::write(&script_path, "println(\"test\");").expect("Failed to write test script");
+
+    // Test file path validation
+    assert!(script_path.exists(), "Script file should exist");
+    assert!(script_path.is_file(), "Script path should be a file");
+
+    // Test directory path validation
+    assert!(temp_dir.path().exists(), "Temp directory should exist");
+    assert!(temp_dir.path().is_dir(), "Temp path should be a directory");
+
+    // Test non-existent path
+    let nonexistent = temp_dir.path().join("nonexistent.rhai");
+    assert!(!nonexistent.exists(), "Non-existent path should not exist");
+}
+
+/// Test file extension checking
+#[test]
+fn test_file_extension_checking() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create files with different extensions
+    let rhai_file = temp_dir.path().join("script.rhai");
+    let txt_file = temp_dir.path().join("document.txt");
+    let no_ext_file = temp_dir.path().join("no_extension");
+
+    fs::write(&rhai_file, "// Rhai script").expect("Failed to write rhai file");
+    fs::write(&txt_file, "Text document").expect("Failed to write txt file");
+    fs::write(&no_ext_file, "No extension").expect("Failed to write no extension file");
+
+    // Test extension detection
+    assert_eq!(rhai_file.extension().unwrap(), "rhai");
+    assert_eq!(txt_file.extension().unwrap(), "txt");
+    assert!(no_ext_file.extension().is_none());
+
+    // Test extension comparison
+    assert!(rhai_file.extension().map_or(false, |ext| ext == "rhai"));
+    assert!(!txt_file.extension().map_or(false, |ext| ext == "rhai"));
+    assert!(!no_ext_file.extension().map_or(false, |ext| ext == "rhai"));
+}
+
+/// Test script content reading
+#[test]
+fn test_script_content_reading() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let script_path = temp_dir.path().join("content_test.rhai");
+
+    let expected_content = r#"
+        println("Testing content reading");
+        let value = 42;
+        value * 2
+    "#;
+
+    fs::write(&script_path, expected_content).expect("Failed to write script content");
+
+    // Read the content back
+    let actual_content = fs::read_to_string(&script_path).expect("Failed to read script content");
+    assert_eq!(
+        actual_content, expected_content,
+        "Script content should match"
+    );
+
+    // Verify content contains expected elements
+    assert!(
+        actual_content.contains("println"),
+        "Content should contain println"
+    );
+    assert!(
+        actual_content.contains("let value = 42"),
+        "Content should contain variable declaration"
+    );
+    assert!(
+        actual_content.contains("value * 2"),
+        "Content should contain expression"
+    );
+}
+
+/// Test directory traversal logic
+#[test]
+fn test_directory_traversal() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create nested directory structure
+    let level1 = temp_dir.path().join("level1");
+    let level2 = level1.join("level2");
+    let level3 = level2.join("level3");
+
+    fs::create_dir_all(&level3).expect("Failed to create nested directories");
+
+    // Create scripts at different levels
+    fs::write(temp_dir.path().join("root.rhai"), "// Root script")
+        .expect("Failed to write root script");
+    fs::write(level1.join("level1.rhai"), "// Level 1 script")
+        .expect("Failed to write level1 script");
+    fs::write(level2.join("level2.rhai"), "// Level 2 script")
+        .expect("Failed to write level2 script");
+    fs::write(level3.join("level3.rhai"), "// Level 3 script")
+        .expect("Failed to write level3 script");
+
+    // Verify directory structure
+    assert!(temp_dir.path().is_dir(), "Root temp directory should exist");
+    assert!(level1.is_dir(), "Level 1 directory should exist");
+    assert!(level2.is_dir(), "Level 2 directory should exist");
+    assert!(level3.is_dir(), "Level 3 directory should exist");
+
+    // Verify scripts exist at each level
+    assert!(
+        temp_dir.path().join("root.rhai").exists(),
+        "Root script should exist"
+    );
+    assert!(
+        level1.join("level1.rhai").exists(),
+        "Level 1 script should exist"
+    );
+    assert!(
+        level2.join("level2.rhai").exists(),
+        "Level 2 script should exist"
+    );
+    assert!(
+        level3.join("level3.rhai").exists(),
+        "Level 3 script should exist"
+    );
+}
+
+/// Test sorting behavior for script execution order
+#[test]
+fn test_script_sorting_order() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    // Create scripts with names that should be sorted
+    let scripts = vec![
+        "03_third.rhai",
+        "01_first.rhai",
+        "02_second.rhai",
+        "10_tenth.rhai",
+        "05_fifth.rhai",
+    ];
+
+    for script in &scripts {
+        fs::write(
+            temp_dir.path().join(script),
+            format!("// Script: {}", script),
+        )
+        .expect("Failed to write script");
+    }
+
+    // Collect and sort the scripts manually to verify sorting logic
+    let mut found_scripts = Vec::new();
+    for entry in fs::read_dir(temp_dir.path()).expect("Failed to read directory") {
+        let entry = entry.expect("Failed to get directory entry");
+        let path = entry.path();
+        if path.is_file() && path.extension().map_or(false, |ext| ext == "rhai") {
+            found_scripts.push(path.file_name().unwrap().to_string_lossy().to_string());
+        }
+    }
+
+    found_scripts.sort();
+
+    // Verify sorting order
+    let expected_order = vec![
+        "01_first.rhai",
+        "02_second.rhai",
+        "03_third.rhai",
+        "05_fifth.rhai",
+        "10_tenth.rhai",
+    ];
+
+    assert_eq!(
+        found_scripts, expected_order,
+        "Scripts should be sorted in correct order"
+    );
+}
+
+/// Test empty directory handling
+#[test]
+fn test_empty_directory_detection() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let empty_subdir = temp_dir.path().join("empty");
+
+    fs::create_dir(&empty_subdir).expect("Failed to create empty subdirectory");
+
+    // Verify directory is empty
+    let entries: Vec<_> = fs::read_dir(&empty_subdir)
+        .expect("Failed to read empty directory")
+        .collect();
+
+    assert!(entries.is_empty(), "Directory should be empty");
+
+    // Count .rhai files in empty directory
+    let mut rhai_count = 0;
+    for entry in fs::read_dir(&empty_subdir).expect("Failed to read empty directory") {
+        let entry = entry.expect("Failed to get directory entry");
+        let path = entry.path();
+        if path.is_file() && path.extension().map_or(false, |ext| ext == "rhai") {
+            rhai_count += 1;
+        }
+    }
+
+    assert_eq!(
+        rhai_count, 0,
+        "Empty directory should contain no .rhai files"
+    );
+}

installers/base.rhai

@@ -0,0 +1,47 @@
+
+
+
+fn mycelium(){
+    let name="mycelium";
+    let url="https://github.com/threefoldtech/mycelium/releases/download/v0.6.1/mycelium-x86_64-unknown-linux-musl.tar.gz";
+    download(url,`/tmp/${name}`,5000);
+    copy_bin(`/tmp/${name}/*`);
+    delete(`/tmp/${name}`);
+    
+    let name="containerd";
+
+}
+
+
+fn zinit(){
+    let name="zinit";
+    let url="https://github.com/threefoldtech/zinit/releases/download/v0.2.25/zinit-linux-x86_64";
+    download_file(url,`/tmp/${name}`,5000);
+    screen_kill("zinit");
+    copy_bin(`/tmp/${name}`);
+    delete(`/tmp/${name}`);
+    screen_new("zinit", "zinit init");
+    sleep(1);
+    let socket_path = "/tmp/zinit.sock";
+
+    // List all services
+    print("Listing all services:");
+    let services = zinit_list(socket_path);
+
+    if services.is_empty() {
+        print("No services found.");
+    } else {
+        // Iterate over the keys of the map
+        for name in services.keys() {
+            let state = services[name];
+            print(`${name}: ${state}`);
+        }
+    }
+    
+}
+
+platform_check_linux_x86();
+zinit();
+// mycelium();
+
+"done"

installers/install_all.rhai

@@ -0,0 +1,7 @@
+
+
+platform_check_linux_x86();
+
+exec(`https://git.threefold.info/herocode/sal/raw/branch/main/installers/base.rhai`);
+//install all we need for nerdctl
+exec(`https://git.threefold.info/herocode/sal/raw/branch/main/installers/nerdctl.rhai`);

installers/nerdctl.rhai

@@ -0,0 +1,54 @@
+
+
+
+fn nerdctl_download(){
+    let name="nerdctl";
+    let url="https://github.com/containerd/nerdctl/releases/download/v2.1.2/nerdctl-2.1.2-linux-amd64.tar.gz";
+    download(url,`/tmp/${name}`,10000);
+    copy_bin(`/tmp/${name}/*`);
+    delete(`/tmp/${name}`);
+    
+    screen_kill("containerd");
+    let name="containerd";
+    let url="https://github.com/containerd/containerd/releases/download/v2.1.2/containerd-2.1.2-linux-amd64.tar.gz";
+    download(url,`/tmp/${name}`,20000);
+    // copy_bin(`/tmp/${name}/bin/*`);
+    delete(`/tmp/${name}`);
+
+    let cfg = `
+    [[registry]]
+    location = "localhost:5000"
+    insecure = true
+    `;
+    file_write("/etc/containers/registries.conf", dedent(cfg));
+    screen_new("containerd", "containerd");
+    sleep(1);
+    nerdctl_remove_all();
+    run("nerdctl run -d -p 5000:5000 --name registry registry:2").log().execute();
+
+    package_install("buildah");
+    package_install("runc");
+
+
+    // let url="https://github.com/threefoldtech/rfs/releases/download/v2.0.6/rfs";
+    // download_file(url,`/tmp/rfs`,10000);
+    // chmod_exec("/tmp/rfs");
+    // mv(`/tmp/rfs`,"/root/hero/bin/");
+
+}
+
+fn ipfs_download(){
+    let name="ipfs";
+    let url="https://github.com/ipfs/kubo/releases/download/v0.34.1/kubo_v0.34.1_linux-amd64.tar.gz";
+    download(url,`/tmp/${name}`,20);
+    copy_bin(`/tmp/${name}/kubo/ipfs`);
+    delete(`/tmp/${name}`);
+    
+
+}
+
+platform_check_linux_x86();
+nerdctl_download();
+// ipfs_download();
+
+"done"

packages/clients/hetznerclient/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "sal-hetzner"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+prettytable = "0.10.0"
+reqwest.workspace = true
+rhai = { workspace = true, features = ["serde"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+thiserror.workspace = true

packages/clients/hetznerclient/src/api/error.rs

@@ -0,0 +1,54 @@
+use std::fmt;
+
+use serde::Deserialize;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AppError {
+    #[error("Request failed: {0}")]
+    RequestError(#[from] reqwest::Error),
+    #[error("API error: {0}")]
+    ApiError(ApiError),
+    #[error("Deserialization Error: {0:?}")]
+    SerdeJsonError(#[from] serde_json::Error),
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ApiError {
+    pub status: u16,
+    pub message: String,
+}
+
+impl From<reqwest::blocking::Response> for ApiError {
+    fn from(value: reqwest::blocking::Response) -> Self {
+        ApiError {
+            status: value.status().into(),
+            message: value.text().unwrap_or("The API call returned an error.".to_string()),
+        }
+    }
+}
+
+impl fmt::Display for ApiError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[derive(Deserialize)]
+        struct HetznerApiError {
+            code: String,
+            message: String,
+        }
+
+        #[derive(Deserialize)]
+        struct HetznerApiErrorWrapper {
+            error: HetznerApiError,
+        }
+
+        if let Ok(wrapper) = serde_json::from_str::<HetznerApiErrorWrapper>(&self.message) {
+            write!(
+                f,
+                "Status: {}, Code: {}, Message: {}",
+                self.status, wrapper.error.code, wrapper.error.message
+            )
+        } else {
+            write!(f, "Status: {}: {}", self.status, self.message)
+        }
+    }
+}

packages/clients/hetznerclient/src/api/mod.rs

@@ -0,0 +1,513 @@
+pub mod error;
+pub mod models;
+
+use self::models::{
+    Boot, Rescue, Server, SshKey, ServerAddonProduct, ServerAddonProductWrapper,
+    AuctionServerProduct, AuctionServerProductWrapper, AuctionTransaction,
+    AuctionTransactionWrapper, BootWrapper, Cancellation, CancellationWrapper,
+    OrderServerBuilder, OrderServerProduct, OrderServerProductWrapper, RescueWrapped,
+    ServerWrapper, SshKeyWrapper, Transaction, TransactionWrapper,
+    ServerAddonTransaction, ServerAddonTransactionWrapper,
+    OrderServerAddonBuilder,
+};
+use crate::api::error::ApiError;
+use crate::config::Config;
+use error::AppError;
+use reqwest::blocking::Client as HttpClient;
+use serde_json::json;
+
+#[derive(Clone)]
+pub struct Client {
+    http_client: HttpClient,
+    config: Config,
+}
+
+impl Client {
+    pub fn new(config: Config) -> Self {
+        Self {
+            http_client: HttpClient::new(),
+            config,
+        }
+    }
+
+    fn handle_response<T>(&self, response: reqwest::blocking::Response) -> Result<T, AppError>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let status = response.status();
+        let body = response.text()?;
+
+        if status.is_success() {
+            serde_json::from_str::<T>(&body).map_err(Into::into)
+        } else {
+            Err(AppError::ApiError(ApiError {
+                status: status.as_u16(),
+                message: body,
+            }))
+        }
+    }
+
+    pub fn get_server(&self, server_number: i32) -> Result<Server, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/server/{}", self.config.api_url, server_number))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: ServerWrapper = self.handle_response(response)?;
+        Ok(wrapped.server)
+    }
+
+    pub fn get_servers(&self) -> Result<Vec<Server>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/server", self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<ServerWrapper> = self.handle_response(response)?;
+        let servers = wrapped.into_iter().map(|sw| sw.server).collect();
+        Ok(servers)
+    }
+
+    pub fn update_server_name(&self, server_number: i32, name: &str) -> Result<Server, AppError> {
+        let params = [("server_name", name)];
+        let response = self
+            .http_client
+            .post(format!("{}/server/{}", self.config.api_url, server_number))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: ServerWrapper = self.handle_response(response)?;
+        Ok(wrapped.server)
+    }
+
+    pub fn get_cancellation_data(&self, server_number: i32) -> Result<Cancellation, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/server/{}/cancellation",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: CancellationWrapper = self.handle_response(response)?;
+        Ok(wrapped.cancellation)
+    }
+
+    pub fn cancel_server(
+        &self,
+        server_number: i32,
+        cancellation_date: &str,
+    ) -> Result<Cancellation, AppError> {
+        let params = [("cancellation_date", cancellation_date)];
+        let response = self
+            .http_client
+            .post(format!(
+                "{}/server/{}/cancellation",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: CancellationWrapper = self.handle_response(response)?;
+        Ok(wrapped.cancellation)
+    }
+
+    pub fn withdraw_cancellation(&self, server_number: i32) -> Result<(), AppError> {
+        self.http_client
+            .delete(format!(
+                "{}/server/{}/cancellation",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        Ok(())
+    }
+
+    pub fn get_ssh_keys(&self) -> Result<Vec<SshKey>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/key", self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<SshKeyWrapper> = self.handle_response(response)?;
+        let keys = wrapped.into_iter().map(|sk| sk.key).collect();
+        Ok(keys)
+    }
+
+    pub fn get_ssh_key(&self, fingerprint: &str) -> Result<SshKey, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/key/{}", self.config.api_url, fingerprint))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: SshKeyWrapper = self.handle_response(response)?;
+        Ok(wrapped.key)
+    }
+
+    pub fn add_ssh_key(&self, name: &str, data: &str) -> Result<SshKey, AppError> {
+        let params = [("name", name), ("data", data)];
+        let response = self
+            .http_client
+            .post(format!("{}/key", self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: SshKeyWrapper = self.handle_response(response)?;
+        Ok(wrapped.key)
+    }
+
+    pub fn update_ssh_key_name(&self, fingerprint: &str, name: &str) -> Result<SshKey, AppError> {
+        let params = [("name", name)];
+        let response = self
+            .http_client
+            .post(format!("{}/key/{}", self.config.api_url, fingerprint))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: SshKeyWrapper = self.handle_response(response)?;
+        Ok(wrapped.key)
+    }
+
+    pub fn delete_ssh_key(&self, fingerprint: &str) -> Result<(), AppError> {
+        self.http_client
+            .delete(format!("{}/key/{}", self.config.api_url, fingerprint))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        Ok(())
+    }
+    pub fn get_boot_configuration(&self, server_number: i32) -> Result<Boot, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/boot/{}", self.config.api_url, server_number))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: BootWrapper = self.handle_response(response)?;
+        Ok(wrapped.boot)
+    }
+
+    pub fn get_rescue_boot_configuration(&self, server_number: i32) -> Result<Rescue, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/boot/{}/rescue",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: RescueWrapped = self.handle_response(response)?;
+        Ok(wrapped.rescue)
+    }
+
+    pub fn enable_rescue_mode(
+        &self,
+        server_number: i32,
+        os: &str,
+        authorized_keys: Option<&[String]>,
+    ) -> Result<Rescue, AppError> {
+        let mut params = vec![("os", os)];
+        if let Some(keys) = authorized_keys {
+            for key in keys {
+                params.push(("authorized_key[]", key));
+            }
+        }
+        let response = self
+            .http_client
+            .post(format!(
+                "{}/boot/{}/rescue",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: RescueWrapped = self.handle_response(response)?;
+        Ok(wrapped.rescue)
+    }
+
+    pub fn disable_rescue_mode(&self, server_number: i32) -> Result<Rescue, AppError> {
+        let response = self
+            .http_client
+            .delete(format!(
+                "{}/boot/{}/rescue",
+                self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: RescueWrapped = self.handle_response(response)?;
+        Ok(wrapped.rescue)
+    }
+
+    pub fn get_server_products(
+        &self,
+    ) -> Result<Vec<OrderServerProduct>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server/product", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<OrderServerProductWrapper> = self.handle_response(response)?;
+        let products = wrapped.into_iter().map(|sop| sop.product).collect();
+        Ok(products)
+    }
+
+    pub fn get_server_product_by_id(
+        &self,
+        product_id: &str,
+    ) -> Result<OrderServerProduct, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/order/server/product/{}",
+                &self.config.api_url, product_id
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: OrderServerProductWrapper = self.handle_response(response)?;
+        Ok(wrapped.product)
+    }
+    pub fn order_server(&self, order: OrderServerBuilder) -> Result<Transaction, AppError> {
+        let mut params = json!({
+            "product_id": order.product_id,
+            "dist": order.dist,
+            "location": order.location,
+            "authorized_key": order.authorized_keys.unwrap_or_default(),
+        });
+
+        if let Some(addons) = order.addons {
+            params["addon"] = json!(addons);
+        }
+
+        if let Some(test) = order.test {
+            if test {
+                params["test"] = json!(test);
+            }
+        }
+
+        let response = self
+            .http_client
+            .post(format!("{}/order/server/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .json(&params)
+            .send()?;
+
+        let wrapped: TransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+
+    pub fn get_transaction_by_id(&self, transaction_id: &str) -> Result<Transaction, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/order/server/transaction/{}",
+                &self.config.api_url, transaction_id
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: TransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+    pub fn get_transactions(&self) -> Result<Vec<Transaction>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<TransactionWrapper> = self.handle_response(response)?;
+        let transactions = wrapped.into_iter().map(|t| t.transaction).collect();
+        Ok(transactions)
+    }
+    pub fn get_auction_server_products(&self) -> Result<Vec<AuctionServerProduct>, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/order/server_market/product",
+                &self.config.api_url
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<AuctionServerProductWrapper> = self.handle_response(response)?;
+        let products = wrapped.into_iter().map(|asp| asp.product).collect();
+        Ok(products)
+    }
+    pub fn get_auction_server_product_by_id(&self, product_id: &str) -> Result<AuctionServerProduct, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server_market/product/{}", &self.config.api_url, product_id))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: AuctionServerProductWrapper = self.handle_response(response)?;
+        Ok(wrapped.product)
+    }
+    pub fn get_auction_transactions(&self) -> Result<Vec<AuctionTransaction>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server_market/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<AuctionTransactionWrapper> = self.handle_response(response)?;
+        let transactions = wrapped.into_iter().map(|t| t.transaction).collect();
+        Ok(transactions)
+    }
+
+    pub fn get_auction_transaction_by_id(&self, transaction_id: &str) -> Result<AuctionTransaction, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server_market/transaction/{}", &self.config.api_url, transaction_id))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: AuctionTransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+
+    pub fn get_server_addon_products(
+        &self,
+        server_number: i64,
+    ) -> Result<Vec<ServerAddonProduct>, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/order/server_addon/{}/product",
+                &self.config.api_url, server_number
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<ServerAddonProductWrapper> = self.handle_response(response)?;
+        let products = wrapped.into_iter().map(|sap| sap.product).collect();
+        Ok(products)
+    }
+
+    pub fn order_auction_server(
+        &self,
+        product_id: i64,
+        authorized_keys: Vec<String>,
+        dist: Option<String>,
+        arch: Option<String>,
+        lang: Option<String>,
+        comment: Option<String>,
+        addons: Option<Vec<String>>,
+        test: Option<bool>,
+    ) -> Result<AuctionTransaction, AppError> {
+        let mut params: Vec<(&str, String)> = Vec::new();
+
+        params.push(("product_id", product_id.to_string()));
+
+        for key in &authorized_keys {
+            params.push(("authorized_key[]", key.clone()));
+        }
+
+        if let Some(dist) = dist {
+            params.push(("dist", dist));
+        }
+        if let Some(arch) = arch {
+            params.push(("@deprecated arch", arch));
+        }
+        if let Some(lang) = lang {
+            params.push(("lang", lang));
+        }
+        if let Some(comment) = comment {
+            params.push(("comment", comment));
+        }
+        if let Some(addons) = addons {
+            for addon in addons {
+                params.push(("addon[]", addon));
+            }
+        }
+        if let Some(test) = test {
+            params.push(("test", test.to_string()));
+        }
+
+        let response = self
+            .http_client
+            .post(format!("{}/order/server_market/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: AuctionTransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+
+    pub fn get_server_addon_transactions(&self) -> Result<Vec<ServerAddonTransaction>, AppError> {
+        let response = self
+            .http_client
+            .get(format!("{}/order/server_addon/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: Vec<ServerAddonTransactionWrapper> = self.handle_response(response)?;
+        let transactions = wrapped.into_iter().map(|satw| satw.transaction).collect();
+        Ok(transactions)
+    }
+
+    pub fn get_server_addon_transaction_by_id(
+        &self,
+        transaction_id: &str,
+    ) -> Result<ServerAddonTransaction, AppError> {
+        let response = self
+            .http_client
+            .get(format!(
+                "{}/order/server_addon/transaction/{}",
+                &self.config.api_url, transaction_id
+            ))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .send()?;
+
+        let wrapped: ServerAddonTransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+
+    pub fn order_server_addon(
+        &self,
+        order: OrderServerAddonBuilder,
+    ) -> Result<ServerAddonTransaction, AppError> {
+        let mut params = json!({
+            "server_number": order.server_number,
+            "product_id": order.product_id,
+        });
+
+        if let Some(reason) = order.reason {
+            params["reason"] = json!(reason);
+        }
+        if let Some(gateway) = order.gateway {
+            params["gateway"] = json!(gateway);
+        }
+        if let Some(test) = order.test {
+            if test {
+                params["test"] = json!(test);
+            }
+        }
+
+        let response = self
+            .http_client
+            .post(format!("{}/order/server_addon/transaction", &self.config.api_url))
+            .basic_auth(&self.config.username, Some(&self.config.password))
+            .form(&params)
+            .send()?;
+
+        let wrapped: ServerAddonTransactionWrapper = self.handle_response(response)?;
+        Ok(wrapped.transaction)
+    }
+}

packages/clients/hetznerclient/src/config.rs

@@ -0,0 +1,25 @@
+use std::env;
+
+#[derive(Clone)]
+pub struct Config {
+    pub username: String,
+    pub password: String,
+    pub api_url: String,
+}
+
+impl Config {
+    pub fn from_env() -> Result<Self, String> {
+        let username = env::var("HETZNER_USERNAME")
+            .map_err(|_| "HETZNER_USERNAME environment variable not set".to_string())?;
+        let password = env::var("HETZNER_PASSWORD")
+            .map_err(|_| "HETZNER_PASSWORD environment variable not set".to_string())?;
+        let api_url = env::var("HETZNER_API_URL")
+            .unwrap_or_else(|_| "https://robot-ws.your-server.de".to_string());
+
+        Ok(Config {
+            username,
+            password,
+            api_url,
+        })
+    }
+}

packages/clients/hetznerclient/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod api;
+pub mod config;
+pub mod rhai;

packages/clients/hetznerclient/src/rhai/boot.rs

@@ -0,0 +1,63 @@
+use crate::api::{
+    models::{Boot, Rescue},
+    Client,
+};
+use rhai::{plugin::*, Engine};
+
+pub fn register(engine: &mut Engine) {
+    let boot_module = exported_module!(boot_api);
+    engine.register_global_module(boot_module.into());
+}
+
+#[export_module]
+pub mod boot_api {
+    use super::*;
+    use rhai::EvalAltResult;
+
+    #[rhai_fn(name = "get_boot_configuration", return_raw)]
+    pub fn get_boot_configuration(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Boot, Box<EvalAltResult>> {
+        client
+            .get_boot_configuration(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "get_rescue_boot_configuration", return_raw)]
+    pub fn get_rescue_boot_configuration(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Rescue, Box<EvalAltResult>> {
+        client
+            .get_rescue_boot_configuration(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "enable_rescue_mode", return_raw)]
+    pub fn enable_rescue_mode(
+        client: &mut Client,
+        server_number: i64,
+        os: &str,
+        authorized_keys: rhai::Array,
+    ) -> Result<Rescue, Box<EvalAltResult>> {
+        let keys: Vec<String> = authorized_keys
+            .into_iter()
+            .map(|k| k.into_string().unwrap())
+            .collect();
+
+        client
+            .enable_rescue_mode(server_number as i32, os, Some(&keys))
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "disable_rescue_mode", return_raw)]
+    pub fn disable_rescue_mode(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Rescue, Box<EvalAltResult>> {
+        client
+            .disable_rescue_mode(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+}

packages/clients/hetznerclient/src/rhai/mod.rs

@@ -0,0 +1,54 @@
+use rhai::{Engine, EvalAltResult};
+
+use crate::api::models::{
+    AuctionServerProduct, AuctionTransaction, AuctionTransactionProduct, AuthorizedKey, Boot,
+    Cancellation, Cpanel, HostKey, Linux, OrderAuctionServerBuilder, OrderServerAddonBuilder,
+    OrderServerBuilder, OrderServerProduct, Plesk, Rescue, Server, ServerAddonProduct,
+    ServerAddonResource, ServerAddonTransaction, SshKey, Transaction, TransactionProduct, Vnc,
+    Windows,
+};
+
+pub mod boot;
+pub mod printing;
+pub mod server;
+pub mod server_ordering;
+pub mod ssh_keys;
+
+// here just register the hetzner module
+pub fn register_hetzner_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // TODO:register types
+    engine.build_type::<Server>();
+    engine.build_type::<SshKey>();
+    engine.build_type::<Boot>();
+    engine.build_type::<Rescue>();
+    engine.build_type::<Linux>();
+    engine.build_type::<Vnc>();
+    engine.build_type::<Windows>();
+    engine.build_type::<Plesk>();
+    engine.build_type::<Cpanel>();
+    engine.build_type::<Cancellation>();
+    engine.build_type::<OrderServerProduct>();
+    engine.build_type::<Transaction>();
+    engine.build_type::<AuthorizedKey>();
+    engine.build_type::<TransactionProduct>();
+    engine.build_type::<HostKey>();
+    engine.build_type::<AuctionServerProduct>();
+    engine.build_type::<AuctionTransaction>();
+    engine.build_type::<AuctionTransactionProduct>();
+    engine.build_type::<OrderAuctionServerBuilder>();
+    engine.build_type::<OrderServerBuilder>();
+    engine.build_type::<ServerAddonProduct>();
+    engine.build_type::<ServerAddonTransaction>();
+    engine.build_type::<ServerAddonResource>();
+    engine.build_type::<OrderServerAddonBuilder>();
+
+    server::register(engine);
+    ssh_keys::register(engine);
+    boot::register(engine);
+    server_ordering::register(engine);
+
+    // TODO: push hetzner to scope as value client:
+    // scope.push("hetzner", client);
+
+    Ok(())
+}

packages/clients/hetznerclient/src/rhai/printing/mod.rs

@@ -0,0 +1,43 @@
+use rhai::{Array, Engine};
+use crate::{api::models::{OrderServerProduct, AuctionServerProduct, AuctionTransaction, ServerAddonProduct, ServerAddonTransaction, Server, SshKey}};
+
+mod servers_table;
+mod ssh_keys_table;
+mod server_ordering_table;
+
+// This will be called when we print(...) or pretty_print() an Array (with Dynamic values)
+pub fn pretty_print_dispatch(array: Array) {
+    if array.is_empty() {
+        println!("<empty table>");
+        return;
+    }
+
+    let first = &array[0];
+
+    if first.is::<Server>() {
+        println!("Yeah first is server!");
+        servers_table::pretty_print_servers(array);
+    } else if first.is::<SshKey>() {
+        ssh_keys_table::pretty_print_ssh_keys(array);
+    }
+    else if first.is::<OrderServerProduct>() {
+        server_ordering_table::pretty_print_server_products(array);
+    } else if first.is::<AuctionServerProduct>() {
+        server_ordering_table::pretty_print_auction_server_products(array);
+    } else if first.is::<AuctionTransaction>() {
+        server_ordering_table::pretty_print_auction_transactions(array);
+    } else if first.is::<ServerAddonProduct>() {
+        server_ordering_table::pretty_print_server_addon_products(array);
+    } else if first.is::<ServerAddonTransaction>() {
+        server_ordering_table::pretty_print_server_addon_transactions(array);
+    } else {
+        // Generic fallback for other types
+        for item in array {
+            println!("{}", item.to_string());
+        }
+    }
+}
+
+pub fn register(engine: &mut Engine) {
+    engine.register_fn("pretty_print", pretty_print_dispatch);
+}

packages/clients/hetznerclient/src/rhai/printing/server_ordering_table.rs

@@ -0,0 +1,293 @@
+use prettytable::{row, Table};
+use crate::api::models::{OrderServerProduct, ServerAddonProduct, ServerAddonTransaction, ServerAddonResource};
+
+pub fn pretty_print_server_products(products: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "ID",
+        "Name",
+        "Description",
+        "Traffic",
+        "Location",
+        "Price (Net)",
+        "Price (Gross)",
+    ]);
+
+    for product_dyn in products {
+        if let Some(product) = product_dyn.try_cast::<OrderServerProduct>() {
+            let mut price_net = "N/A".to_string();
+            let mut price_gross = "N/A".to_string();
+
+            if let Some(first_price) = product.prices.first() {
+                price_net = first_price.price.net.clone();
+                price_gross = first_price.price.gross.clone();
+            }
+
+            table.add_row(row![
+                product.id,
+                product.name,
+                product.description.join(", "),
+                product.traffic,
+                product.location.join(", "),
+                price_net,
+                price_gross,
+            ]);
+        }
+    }
+    table.printstd();
+}
+
+pub fn pretty_print_auction_server_products(products: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "ID",
+        "Name",
+        "Description",
+        "Traffic",
+        "Distributions",
+        "Architectures",
+        "Languages",
+        "CPU",
+        "CPU Benchmark",
+        "Memory Size (GB)",
+        "HDD Size (GB)",
+        "HDD Text",
+        "HDD Count",
+        "Datacenter",
+        "Network Speed",
+        "Price (Net)",
+        "Price (Hourly Net)",
+        "Price (Setup Net)",
+        "Price (VAT)",
+        "Price (Hourly VAT)",
+        "Price (Setup VAT)",
+        "Fixed Price",
+        "Next Reduce (seconds)",
+        "Next Reduce Date",
+        "Orderable Addons",
+    ]);
+
+    for product_dyn in products {
+        if let Some(product) = product_dyn.try_cast::<crate::api::models::AuctionServerProduct>() {
+            let mut addons_table = Table::new();
+            addons_table.add_row(row![b => "ID", "Name", "Min", "Max", "Prices"]);
+            for addon in &product.orderable_addons {
+                let mut addon_prices_table = Table::new();
+                addon_prices_table.add_row(row![b => "Location", "Net", "Gross", "Hourly Net", "Hourly Gross", "Setup Net", "Setup Gross"]);
+                for price in &addon.prices {
+                    addon_prices_table.add_row(row![
+                        price.location,
+                        price.price.net,
+                        price.price.gross,
+                        price.price.hourly_net,
+                        price.price.hourly_gross,
+                        price.price_setup.net,
+                        price.price_setup.gross
+                    ]);
+                }
+                addons_table.add_row(row![
+                    addon.id,
+                    addon.name,
+                    addon.min,
+                    addon.max,
+                    addon_prices_table
+                ]);
+            }
+
+            table.add_row(row![
+                product.id,
+                product.name,
+                product.description.join(", "),
+                product.traffic,
+                product.dist.join(", "),
+                product.arch.as_deref().unwrap_or_default().join(", "),
+                product.lang.join(", "),
+                product.cpu,
+                product.cpu_benchmark,
+                product.memory_size,
+                product.hdd_size,
+                product.hdd_text,
+                product.hdd_count,
+                product.datacenter,
+                product.network_speed,
+                product.price,
+                product.price_hourly.as_deref().unwrap_or("N/A"),
+                product.price_setup,
+                product.price_with_vat,
+                product.price_hourly_with_vat.as_deref().unwrap_or("N/A"),
+                product.price_setup_with_vat,
+                product.fixed_price,
+                product.next_reduce,
+                product.next_reduce_date,
+                addons_table,
+            ]);
+        }
+    }
+    table.printstd();
+}
+
+pub fn pretty_print_server_addon_products(products: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "ID",
+        "Name",
+        "Type",
+        "Location",
+        "Price (Net)",
+        "Price (Gross)",
+        "Hourly Net",
+        "Hourly Gross",
+        "Setup Net",
+        "Setup Gross",
+    ]);
+
+    for product_dyn in products {
+        if let Some(product) = product_dyn.try_cast::<ServerAddonProduct>() {
+            table.add_row(row![
+                product.id,
+                product.name,
+                product.product_type,
+                product.price.location,
+                product.price.price.net,
+                product.price.price.gross,
+                product.price.price.hourly_net,
+                product.price.price.hourly_gross,
+                product.price.price_setup.net,
+                product.price.price_setup.gross,
+            ]);
+        }
+    }
+    table.printstd();
+}
+
+pub fn pretty_print_auction_transactions(transactions: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "ID",
+        "Date",
+        "Status",
+        "Server Number",
+        "Server IP",
+        "Comment",
+        "Product ID",
+        "Product Name",
+        "Product Traffic",
+        "Product Distributions",
+        "Product Architectures",
+        "Product Languages",
+        "Product CPU",
+        "Product CPU Benchmark",
+        "Product Memory Size (GB)",
+        "Product HDD Size (GB)",
+        "Product HDD Text",
+        "Product HDD Count",
+        "Product Datacenter",
+        "Product Network Speed",
+        "Product Fixed Price",
+        "Product Next Reduce (seconds)",
+        "Product Next Reduce Date",
+        "Addons",
+    ]);
+
+    for transaction_dyn in transactions {
+        if let Some(transaction) = transaction_dyn.try_cast::<crate::api::models::AuctionTransaction>() {
+            let _authorized_keys_table = {
+                let mut table = Table::new();
+                table.add_row(row![b => "Name", "Fingerprint", "Type", "Size"]);
+                for key in &transaction.authorized_key {
+                    table.add_row(row![
+                        key.key.name.as_deref().unwrap_or("N/A"),
+                        key.key.fingerprint.as_deref().unwrap_or("N/A"),
+                        key.key.key_type.as_deref().unwrap_or("N/A"),
+                        key.key.size.map_or("N/A".to_string(), |s| s.to_string())
+                    ]);
+                }
+                table
+            };
+
+            let _host_keys_table = {
+                let mut table = Table::new();
+                table.add_row(row![b => "Fingerprint", "Type", "Size"]);
+                for key in &transaction.host_key {
+                    table.add_row(row![
+                        key.key.fingerprint.as_deref().unwrap_or("N/A"),
+                        key.key.key_type.as_deref().unwrap_or("N/A"),
+                        key.key.size.map_or("N/A".to_string(), |s| s.to_string())
+                    ]);
+                }
+                table
+            };
+
+            table.add_row(row![
+                transaction.id,
+                transaction.date,
+                transaction.status,
+                transaction.server_number.map_or("N/A".to_string(), |id| id.to_string()),
+                transaction.server_ip.as_deref().unwrap_or("N/A"),
+                transaction.comment.as_deref().unwrap_or("N/A"),
+                transaction.product.id,
+                transaction.product.name,
+                transaction.product.traffic,
+                transaction.product.dist,
+                transaction.product.arch.as_deref().unwrap_or("N/A"),
+                transaction.product.lang,
+                transaction.product.cpu,
+                transaction.product.cpu_benchmark,
+                transaction.product.memory_size,
+                transaction.product.hdd_size,
+                transaction.product.hdd_text,
+                transaction.product.hdd_count,
+                transaction.product.datacenter,
+                transaction.product.network_speed,
+                transaction.product.fixed_price.unwrap_or_default().to_string(),
+                transaction
+                    .product
+                    .next_reduce
+                    .map_or("N/A".to_string(), |r| r.to_string()),
+                transaction
+                    .product
+                    .next_reduce_date
+                    .as_deref()
+                    .unwrap_or("N/A"),
+                transaction.addons.join(", "),
+            ]);
+        }
+    }
+    table.printstd();
+}
+
+pub fn pretty_print_server_addon_transactions(transactions: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "ID",
+        "Date",
+        "Status",
+        "Server Number",
+        "Product ID",
+        "Product Name",
+        "Product Price",
+        "Resources",
+    ]);
+
+    for transaction_dyn in transactions {
+        if let Some(transaction) = transaction_dyn.try_cast::<ServerAddonTransaction>() {
+            let mut resources_table = Table::new();
+            resources_table.add_row(row![b => "Type", "ID"]);
+            for resource in &transaction.resources {
+                resources_table.add_row(row![resource.resource_type, resource.id]);
+            }
+
+            table.add_row(row![
+                transaction.id,
+                transaction.date,
+                transaction.status,
+                transaction.server_number,
+                transaction.product.id,
+                transaction.product.name,
+                transaction.product.price.to_string(),
+                resources_table,
+            ]);
+        }
+    }
+    table.printstd();
+}

packages/clients/hetznerclient/src/rhai/printing/servers_table.rs

@@ -0,0 +1,30 @@
+use prettytable::{row, Table};
+use rhai::Array;
+
+use super::Server;
+
+pub fn pretty_print_servers(servers: Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "Number",
+        "Name",
+        "IP",
+        "Product",
+        "DC",
+        "Status"
+    ]);
+
+    for server_dyn in servers {
+        if let Some(server) = server_dyn.try_cast::<Server>() {
+            table.add_row(row![
+                server.server_number.to_string(),
+                server.server_name,
+                server.server_ip.unwrap_or("N/A".to_string()),
+                server.product,
+                server.dc,
+                server.status
+            ]);
+        }
+    }
+    table.printstd();
+}

packages/clients/hetznerclient/src/rhai/printing/ssh_keys_table.rs

@@ -0,0 +1,26 @@
+use prettytable::{row, Table};
+use super::SshKey;
+
+pub fn pretty_print_ssh_keys(keys: rhai::Array) {
+    let mut table = Table::new();
+    table.add_row(row![b =>
+        "Name",
+        "Fingerprint",
+        "Type",
+        "Size",
+        "Created At"
+    ]);
+
+    for key_dyn in keys {
+        if let Some(key) = key_dyn.try_cast::<SshKey>() {
+            table.add_row(row![
+                key.name,
+                key.fingerprint,
+                key.key_type,
+                key.size.to_string(),
+                key.created_at
+            ]);
+        }
+    }
+    table.printstd();
+}

packages/clients/hetznerclient/src/rhai/server.rs

@@ -0,0 +1,76 @@
+use crate::api::{Client, models::Server};
+use rhai::{Array, Dynamic, plugin::*};
+
+pub fn register(engine: &mut Engine) {
+    let server_module = exported_module!(server_api);
+    engine.register_global_module(server_module.into());
+}
+
+#[export_module]
+pub mod server_api {
+    use crate::api::models::Cancellation;
+
+    use super::*;
+    use rhai::EvalAltResult;
+
+    #[rhai_fn(name = "get_server", return_raw)]
+    pub fn get_server(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Server, Box<EvalAltResult>> {
+        client
+            .get_server(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "get_servers", return_raw)]
+    pub fn get_servers(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
+        let servers = client
+            .get_servers()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        println!("number of SERVERS we got: {:#?}", servers.len());
+        Ok(servers.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "update_server_name", return_raw)]
+    pub fn update_server_name(
+        client: &mut Client,
+        server_number: i64,
+        name: &str,
+    ) -> Result<Server, Box<EvalAltResult>> {
+        client
+            .update_server_name(server_number as i32, name)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "get_cancellation_data", return_raw)]
+    pub fn get_cancellation_data(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Cancellation, Box<EvalAltResult>> {
+        client
+            .get_cancellation_data(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "cancel_server", return_raw)]
+    pub fn cancel_server(
+        client: &mut Client,
+        server_number: i64,
+        cancellation_date: &str,
+    ) -> Result<Cancellation, Box<EvalAltResult>> {
+        client
+            .cancel_server(server_number as i32, cancellation_date)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "withdraw_cancellation", return_raw)]
+    pub fn withdraw_cancellation(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<(), Box<EvalAltResult>> {
+        client
+            .withdraw_cancellation(server_number as i32)
+            .map_err(|e| e.to_string().into())
+    }
+}

packages/clients/hetznerclient/src/rhai/server_ordering.rs

@@ -0,0 +1,170 @@
+use crate::api::{
+    Client,
+    models::{
+        AuctionServerProduct, AuctionTransaction, OrderAuctionServerBuilder, OrderServerBuilder,
+        OrderServerProduct, ServerAddonProduct, ServerAddonTransaction, Transaction,
+    },
+};
+use rhai::{Array, Dynamic, plugin::*};
+
+pub fn register(engine: &mut Engine) {
+    let server_order_module = exported_module!(server_order_api);
+    engine.register_global_module(server_order_module.into());
+}
+
+#[export_module]
+pub mod server_order_api {
+    use crate::api::models::OrderServerAddonBuilder;
+
+    #[rhai_fn(name = "get_server_products", return_raw)]
+    pub fn get_server_ordering_product_overview(
+        client: &mut Client,
+    ) -> Result<Array, Box<EvalAltResult>> {
+        let overview_servers = client
+            .get_server_products()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(overview_servers.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_server_product_by_id", return_raw)]
+    pub fn get_server_ordering_product_by_id(
+        client: &mut Client,
+        product_id: &str,
+    ) -> Result<OrderServerProduct, Box<EvalAltResult>> {
+        let product = client
+            .get_server_product_by_id(product_id)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(product)
+    }
+
+    #[rhai_fn(name = "order_server", return_raw)]
+    pub fn order_server(
+        client: &mut Client,
+        order: OrderServerBuilder,
+    ) -> Result<Transaction, Box<EvalAltResult>> {
+        let transaction = client
+            .order_server(order)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+
+    #[rhai_fn(name = "get_transaction_by_id", return_raw)]
+    pub fn get_transaction_by_id(
+        client: &mut Client,
+        transaction_id: &str,
+    ) -> Result<Transaction, Box<EvalAltResult>> {
+        let transaction = client
+            .get_transaction_by_id(transaction_id)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+
+    #[rhai_fn(name = "get_transactions", return_raw)]
+    pub fn get_transactions(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
+        let transactions = client
+            .get_transactions()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transactions.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_auction_server_products", return_raw)]
+    pub fn get_auction_server_products(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
+        let products = client
+            .get_auction_server_products()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(products.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_auction_server_product_by_id", return_raw)]
+    pub fn get_auction_server_product_by_id(
+        client: &mut Client,
+        product_id: &str,
+    ) -> Result<AuctionServerProduct, Box<EvalAltResult>> {
+        let product = client
+            .get_auction_server_product_by_id(product_id)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(product)
+    }
+
+    #[rhai_fn(name = "get_auction_transactions", return_raw)]
+    pub fn get_auction_transactions(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
+        let transactions = client
+            .get_auction_transactions()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transactions.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_auction_transaction_by_id", return_raw)]
+    pub fn get_auction_transaction_by_id(
+        client: &mut Client,
+        transaction_id: &str,
+    ) -> Result<AuctionTransaction, Box<EvalAltResult>> {
+        let transaction = client
+            .get_auction_transaction_by_id(transaction_id)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+
+    #[rhai_fn(name = "get_server_addon_products", return_raw)]
+    pub fn get_server_addon_products(
+        client: &mut Client,
+        server_number: i64,
+    ) -> Result<Array, Box<EvalAltResult>> {
+        let products = client
+            .get_server_addon_products(server_number)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(products.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_server_addon_transactions", return_raw)]
+    pub fn get_server_addon_transactions(
+        client: &mut Client,
+    ) -> Result<Array, Box<EvalAltResult>> {
+        let transactions = client
+            .get_server_addon_transactions()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transactions.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_server_addon_transaction_by_id", return_raw)]
+    pub fn get_server_addon_transaction_by_id(
+        client: &mut Client,
+        transaction_id: &str,
+    ) -> Result<ServerAddonTransaction, Box<EvalAltResult>> {
+        let transaction = client
+            .get_server_addon_transaction_by_id(transaction_id)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+
+    #[rhai_fn(name = "order_auction_server", return_raw)]
+    pub fn order_auction_server(
+        client: &mut Client,
+        order: OrderAuctionServerBuilder,
+    ) -> Result<AuctionTransaction, Box<EvalAltResult>> {
+        println!("Builder struct being used to order server: {:#?}", order);
+        let transaction = client.order_auction_server(
+            order.product_id,
+            order.authorized_keys.unwrap_or(vec![]),
+            order.dist,
+            None,
+            order.lang,
+            order.comment,
+            order.addon,
+            order.test,
+        ).map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+
+    #[rhai_fn(name = "order_server_addon", return_raw)]
+    pub fn order_server_addon(
+        client: &mut Client,
+        order: OrderServerAddonBuilder,
+    ) -> Result<ServerAddonTransaction, Box<EvalAltResult>> {
+        println!("Builder struct being used to order server addon: {:#?}", order);
+        let transaction = client
+            .order_server_addon(order)
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(transaction)
+    }
+}

packages/clients/hetznerclient/src/rhai/ssh_keys.rs

@@ -0,0 +1,89 @@
+use crate::api::{Client, models::SshKey};
+use prettytable::{Table, row};
+use rhai::{Array, Dynamic, Engine, plugin::*};
+
+pub fn register(engine: &mut Engine) {
+    let ssh_keys_module = exported_module!(ssh_keys_api);
+    engine.register_global_module(ssh_keys_module.into());
+}
+
+#[export_module]
+pub mod ssh_keys_api {
+    use super::*;
+    use rhai::EvalAltResult;
+
+    #[rhai_fn(name = "get_ssh_keys", return_raw)]
+    pub fn get_ssh_keys(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
+        let ssh_keys = client
+            .get_ssh_keys()
+            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
+        Ok(ssh_keys.into_iter().map(Dynamic::from).collect())
+    }
+
+    #[rhai_fn(name = "get_ssh_key", return_raw)]
+    pub fn get_ssh_key(
+        client: &mut Client,
+        fingerprint: &str,
+    ) -> Result<SshKey, Box<EvalAltResult>> {
+        client
+            .get_ssh_key(fingerprint)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "add_ssh_key", return_raw)]
+    pub fn add_ssh_key(
+        client: &mut Client,
+        name: &str,
+        data: &str,
+    ) -> Result<SshKey, Box<EvalAltResult>> {
+        client
+            .add_ssh_key(name, data)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "update_ssh_key_name", return_raw)]
+    pub fn update_ssh_key_name(
+        client: &mut Client,
+        fingerprint: &str,
+        name: &str,
+    ) -> Result<SshKey, Box<EvalAltResult>> {
+        client
+            .update_ssh_key_name(fingerprint, name)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "delete_ssh_key", return_raw)]
+    pub fn delete_ssh_key(
+        client: &mut Client,
+        fingerprint: &str,
+    ) -> Result<(), Box<EvalAltResult>> {
+        client
+            .delete_ssh_key(fingerprint)
+            .map_err(|e| e.to_string().into())
+    }
+
+    #[rhai_fn(name = "pretty_print")]
+    pub fn pretty_print_ssh_keys(keys: Array) {
+        let mut table = Table::new();
+        table.add_row(row![b =>
+            "Name",
+            "Fingerprint",
+            "Type",
+            "Size",
+            "Created At"
+        ]);
+
+        for key_dyn in keys {
+            if let Some(key) = key_dyn.try_cast::<SshKey>() {
+                table.add_row(row![
+                    key.name,
+                    key.fingerprint,
+                    key.key_type,
+                    key.size.to_string(),
+                    key.created_at
+                ]);
+            }
+        }
+        table.printstd();
+    }
+}

packages/clients/myceliumclient/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "sal-mycelium"
+version = "0.1.0"
+edition = "2021"
+authors = ["PlanetFirst <info@incubaid.com>"]
+description = "SAL Mycelium - Client interface for interacting with Mycelium node's HTTP API"
+repository = "https://git.threefold.info/herocode/sal"
+license = "Apache-2.0"
+
+[dependencies]
+# HTTP client for async requests
+reqwest = { workspace = true }
+# JSON handling
+serde_json = { workspace = true }
+# Base64 encoding/decoding for message payloads
+base64 = { workspace = true }
+# Async runtime
+tokio = { workspace = true }
+# Rhai scripting support
+rhai = { workspace = true }
+# Logging
+log = { workspace = true }
+# URL encoding for API parameters
+urlencoding = { workspace = true }
+
+[dev-dependencies]
+# For async testing
+tokio-test = { workspace = true }
+# For temporary files in tests
+tempfile = { workspace = true }

packages/clients/myceliumclient/README.md

@@ -0,0 +1,119 @@
+# SAL Mycelium (`sal-mycelium`)
+
+A Rust client library for interacting with Mycelium node's HTTP API, with Rhai scripting support.
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+sal-mycelium = "0.1.0"
+```
+
+## Overview
+
+SAL Mycelium provides async HTTP client functionality for managing Mycelium nodes, including:
+
+- Node information retrieval
+- Peer management (list, add, remove)
+- Route inspection (selected and fallback routes)
+- Message operations (send and receive)
+
+## Usage
+
+### Rust API
+
+```rust
+use sal_mycelium::*;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let api_url = "http://localhost:8989";
+    
+    // Get node information
+    let node_info = get_node_info(api_url).await?;
+    println!("Node info: {:?}", node_info);
+    
+    // List peers
+    let peers = list_peers(api_url).await?;
+    println!("Peers: {:?}", peers);
+    
+    // Send a message
+    use std::time::Duration;
+    let result = send_message(
+        api_url,
+        "destination_ip",
+        "topic",
+        "Hello, Mycelium!",
+        Some(Duration::from_secs(30))
+    ).await?;
+    
+    Ok(())
+}
+```
+
+### Rhai Scripting
+
+```rhai
+// Get node information
+let api_url = "http://localhost:8989";
+let node_info = mycelium_get_node_info(api_url);
+print(`Node subnet: ${node_info.nodeSubnet}`);
+
+// List peers
+let peers = mycelium_list_peers(api_url);
+print(`Found ${peers.len()} peers`);
+
+// Send message (timeout in seconds, -1 for no timeout)
+let result = mycelium_send_message(api_url, "dest_ip", "topic", "message", 30);
+```
+
+## API Functions
+
+### Core Functions
+
+- `get_node_info(api_url)` - Get node information
+- `list_peers(api_url)` - List connected peers
+- `add_peer(api_url, peer_address)` - Add a new peer
+- `remove_peer(api_url, peer_id)` - Remove a peer
+- `list_selected_routes(api_url)` - List selected routes
+- `list_fallback_routes(api_url)` - List fallback routes
+- `send_message(api_url, destination, topic, message, timeout)` - Send message
+- `receive_messages(api_url, topic, timeout)` - Receive messages
+
+### Rhai Functions
+
+All functions are available in Rhai with `mycelium_` prefix:
+- `mycelium_get_node_info(api_url)`
+- `mycelium_list_peers(api_url)`
+- `mycelium_add_peer(api_url, peer_address)`
+- `mycelium_remove_peer(api_url, peer_id)`
+- `mycelium_list_selected_routes(api_url)`
+- `mycelium_list_fallback_routes(api_url)`
+- `mycelium_send_message(api_url, destination, topic, message, timeout_secs)`
+- `mycelium_receive_messages(api_url, topic, timeout_secs)`
+
+## Requirements
+
+- A running Mycelium node with HTTP API enabled
+- Default API endpoint: `http://localhost:8989`
+
+## Testing
+
+```bash
+# Run all tests
+cargo test
+
+# Run with a live Mycelium node for integration tests
+# (tests will skip if no node is available)
+cargo test -- --nocapture
+```
+
+## Dependencies
+
+- `reqwest` - HTTP client
+- `serde_json` - JSON handling
+- `base64` - Message encoding
+- `tokio` - Async runtime
+- `rhai` - Scripting support

packages/clients/myceliumclient/src/lib.rs

@@ -0,0 +1,327 @@
+//! SAL Mycelium - Client interface for interacting with Mycelium node's HTTP API
+//!
+//! This crate provides a client interface for interacting with a Mycelium node's HTTP API.
+//! Mycelium is a decentralized networking project, and this SAL module allows Rust applications
+//! and `herodo` Rhai scripts to manage and communicate over a Mycelium network.
+//!
+//! The module enables operations such as:
+//! - Querying node status and information
+//! - Managing peer connections (listing, adding, removing)
+//! - Inspecting routing tables (selected and fallback routes)
+//! - Sending messages to other Mycelium nodes
+//! - Receiving messages from subscribed topics
+//!
+//! All interactions with the Mycelium API are performed asynchronously.
+
+use base64::{engine::general_purpose, Engine as _};
+use reqwest::Client;
+use serde_json::Value;
+use std::time::Duration;
+
+pub mod rhai;
+
+/// Get information about the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The node information as a JSON value, or an error message
+pub async fn get_node_info(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all peers connected to the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of peers as a JSON value, or an error message
+pub async fn list_peers(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/peers", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Add a new peer to the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `peer_address` - The address of the peer to add
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn add_peer(api_url: &str, peer_address: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/peers", api_url);
+
+    let response = client
+        .post(&url)
+        .json(&serde_json::json!({
+            "endpoint": peer_address
+        }))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if status == reqwest::StatusCode::NO_CONTENT {
+        // Successfully added, but no content to parse
+        return Ok(serde_json::json!({"success": true}));
+    }
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    // For other success statuses that might have a body
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Remove a peer from the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `peer_id` - The ID of the peer to remove
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn remove_peer(api_url: &str, peer_id: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let peer_id_url_encoded = urlencoding::encode(peer_id);
+    let url = format!("{}/api/v1/admin/peers/{}", api_url, peer_id_url_encoded);
+
+    let response = client
+        .delete(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if status == reqwest::StatusCode::NO_CONTENT {
+        // Successfully removed, but no content to parse
+        return Ok(serde_json::json!({"success": true}));
+    }
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all selected routes in the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of selected routes as a JSON value, or an error message
+pub async fn list_selected_routes(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/routes/selected", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all fallback routes in the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of fallback routes as a JSON value, or an error message
+pub async fn list_fallback_routes(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/routes/fallback", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Send a message to a destination via the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `destination` - The destination address
+/// * `topic` - The message topic
+/// * `message` - The message content
+/// * `reply_deadline` - The deadline in seconds; pass `-1` to indicate we do not want to wait on a reply
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn send_message(
+    api_url: &str,
+    destination: &str,
+    topic: &str,
+    message: &str,
+    reply_deadline: Option<Duration>, // This is passed in URL query
+) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/messages", api_url);
+
+    let mut request = client.post(&url);
+    if let Some(deadline) = reply_deadline {
+        request = request.query(&[("reply_timeout", deadline.as_secs())]);
+    }
+
+    let response = request
+        .json(&serde_json::json!({
+                "dst": { "ip": destination },
+                "topic": general_purpose::STANDARD.encode(topic),
+                "payload": general_purpose::STANDARD.encode(message)
+        }))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Receive messages from a topic via the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `topic` - The message topic
+/// * `wait_deadline` - Time we wait for receiving a message
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The received messages as a JSON value, or an error message
+pub async fn receive_messages(
+    api_url: &str,
+    topic: &str,
+    wait_deadline: Option<Duration>,
+) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/messages", api_url);
+
+    let mut request = client.get(&url);
+
+    if let Some(deadline) = wait_deadline {
+        request = request.query(&[
+            ("topic", general_purpose::STANDARD.encode(topic)),
+            ("timeout", deadline.as_secs().to_string()),
+        ])
+    } else {
+        request = request.query(&[("topic", general_purpose::STANDARD.encode(topic))])
+    };
+
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}

packages/clients/myceliumclient/src/rhai.rs

@@ -0,0 +1,254 @@
+//! Rhai wrappers for Mycelium client module functions
+//!
+//! This module provides Rhai wrappers for the functions in the Mycelium client module.
+
+use std::time::Duration;
+
+use crate as client;
+use rhai::Position;
+use rhai::{Array, Dynamic, Engine, EvalAltResult, Map};
+use serde_json::Value;
+use tokio::runtime::Runtime;
+
+/// Register Mycelium module functions with the Rhai engine
+///
+/// # Arguments
+///
+/// * `engine` - The Rhai engine to register the functions with
+///
+/// # Returns
+///
+/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
+pub fn register_mycelium_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register Mycelium client functions
+    engine.register_fn("mycelium_get_node_info", mycelium_get_node_info);
+    engine.register_fn("mycelium_list_peers", mycelium_list_peers);
+    engine.register_fn("mycelium_add_peer", mycelium_add_peer);
+    engine.register_fn("mycelium_remove_peer", mycelium_remove_peer);
+    engine.register_fn(
+        "mycelium_list_selected_routes",
+        mycelium_list_selected_routes,
+    );
+    engine.register_fn(
+        "mycelium_list_fallback_routes",
+        mycelium_list_fallback_routes,
+    );
+    engine.register_fn("mycelium_send_message", mycelium_send_message);
+    engine.register_fn("mycelium_receive_messages", mycelium_receive_messages);
+
+    Ok(())
+}
+
+// Helper function to get a runtime
+fn get_runtime() -> Result<Runtime, Box<EvalAltResult>> {
+    tokio::runtime::Runtime::new().map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Failed to create Tokio runtime: {}", e).into(),
+            rhai::Position::NONE,
+        ))
+    })
+}
+
+// Helper function to convert serde_json::Value to rhai::Dynamic
+fn value_to_dynamic(value: Value) -> Dynamic {
+    match value {
+        Value::Null => Dynamic::UNIT,
+        Value::Bool(b) => Dynamic::from(b),
+        Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Dynamic::from(i)
+            } else if let Some(f) = n.as_f64() {
+                Dynamic::from(f)
+            } else {
+                Dynamic::from(n.to_string())
+            }
+        }
+        Value::String(s) => Dynamic::from(s),
+        Value::Array(arr) => {
+            let mut rhai_arr = Array::new();
+            for item in arr {
+                rhai_arr.push(value_to_dynamic(item));
+            }
+            Dynamic::from(rhai_arr)
+        }
+        Value::Object(map) => {
+            let mut rhai_map = Map::new();
+            for (k, v) in map {
+                rhai_map.insert(k.into(), value_to_dynamic(v));
+            }
+            Dynamic::from_map(rhai_map)
+        }
+    }
+}
+
+//
+// Mycelium Client Function Wrappers
+//
+
+/// Wrapper for mycelium::get_node_info
+///
+/// Gets information about the Mycelium node.
+pub fn mycelium_get_node_info(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::get_node_info(api_url).await });
+
+    let node_info = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(node_info))
+}
+
+/// Wrapper for mycelium::list_peers
+///
+/// Lists all peers connected to the Mycelium node.
+pub fn mycelium_list_peers(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::list_peers(api_url).await });
+
+    let peers = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(peers))
+}
+
+/// Wrapper for mycelium::add_peer
+///
+/// Adds a new peer to the Mycelium node.
+pub fn mycelium_add_peer(api_url: &str, peer_address: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::add_peer(api_url, peer_address).await });
+
+    let response = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::remove_peer
+///
+/// Removes a peer from the Mycelium node.
+pub fn mycelium_remove_peer(api_url: &str, peer_id: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::remove_peer(api_url, peer_id).await });
+
+    let response = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::list_selected_routes
+///
+/// Lists all selected routes in the Mycelium node.
+pub fn mycelium_list_selected_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::list_selected_routes(api_url).await });
+
+    let routes = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(routes))
+}
+
+/// Wrapper for mycelium::list_fallback_routes
+///
+/// Lists all fallback routes in the Mycelium node.
+pub fn mycelium_list_fallback_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let result = rt.block_on(async { client::list_fallback_routes(api_url).await });
+
+    let routes = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(routes))
+}
+
+/// Wrapper for mycelium::send_message
+///
+/// Sends a message to a destination via the Mycelium node.
+pub fn mycelium_send_message(
+    api_url: &str,
+    destination: &str,
+    topic: &str,
+    message: &str,
+    reply_deadline_secs: i64,
+) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let deadline = if reply_deadline_secs < 0 {
+        None
+    } else {
+        Some(Duration::from_secs(reply_deadline_secs as u64))
+    };
+
+    let result = rt.block_on(async {
+        client::send_message(api_url, destination, topic, message, deadline).await
+    });
+
+    let response = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::receive_messages
+///
+/// Receives messages from a topic via the Mycelium node.
+pub fn mycelium_receive_messages(
+    api_url: &str,
+    topic: &str,
+    wait_deadline_secs: i64,
+) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+
+    let deadline = if wait_deadline_secs < 0 {
+        None
+    } else {
+        Some(Duration::from_secs(wait_deadline_secs as u64))
+    };
+
+    let result = rt.block_on(async { client::receive_messages(api_url, topic, deadline).await });
+
+    let messages = result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Mycelium error: {}", e).into(),
+            Position::NONE,
+        ))
+    })?;
+
+    Ok(value_to_dynamic(messages))
+}

packages/clients/myceliumclient/tests/mycelium_client_tests.rs

@@ -0,0 +1,279 @@
+//! Unit tests for Mycelium client functionality
+//!
+//! These tests validate the core Mycelium client operations including:
+//! - Node information retrieval
+//! - Peer management (listing, adding, removing)
+//! - Route inspection (selected and fallback routes)
+//! - Message operations (sending and receiving)
+//!
+//! Tests are designed to work with a real Mycelium node when available,
+//! but gracefully handle cases where the node is not accessible.
+
+use sal_mycelium::*;
+use std::time::Duration;
+
+/// Test configuration for Mycelium API
+const TEST_API_URL: &str = "http://localhost:8989";
+const FALLBACK_API_URL: &str = "http://localhost:7777";
+
+/// Helper function to check if a Mycelium node is available
+async fn is_mycelium_available(api_url: &str) -> bool {
+    match get_node_info(api_url).await {
+        Ok(_) => true,
+        Err(_) => false,
+    }
+}
+
+/// Helper function to get an available Mycelium API URL
+async fn get_available_api_url() -> Option<String> {
+    if is_mycelium_available(TEST_API_URL).await {
+        Some(TEST_API_URL.to_string())
+    } else if is_mycelium_available(FALLBACK_API_URL).await {
+        Some(FALLBACK_API_URL.to_string())
+    } else {
+        None
+    }
+}
+
+#[tokio::test]
+async fn test_get_node_info_success() {
+    if let Some(api_url) = get_available_api_url().await {
+        let result = get_node_info(&api_url).await;
+
+        match result {
+            Ok(node_info) => {
+                // Validate that we got a JSON response with expected fields
+                assert!(node_info.is_object(), "Node info should be a JSON object");
+
+                // Check for common Mycelium node info fields
+                let obj = node_info.as_object().unwrap();
+
+                // These fields are typically present in Mycelium node info
+                // We check if at least one of them exists to validate the response
+                let has_expected_fields = obj.contains_key("nodeSubnet")
+                    || obj.contains_key("nodePubkey")
+                    || obj.contains_key("peers")
+                    || obj.contains_key("routes");
+
+                assert!(
+                    has_expected_fields,
+                    "Node info should contain expected Mycelium fields"
+                );
+                println!("✓ Node info retrieved successfully: {:?}", node_info);
+            }
+            Err(e) => {
+                // If we can connect but get an error, it might be a version mismatch
+                // or API change - log it but don't fail the test
+                println!("⚠ Node info request failed (API might have changed): {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_get_node_info_success: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_get_node_info_invalid_url() {
+    let invalid_url = "http://localhost:99999";
+    let result = get_node_info(invalid_url).await;
+
+    assert!(result.is_err(), "Should fail with invalid URL");
+    let error = result.unwrap_err();
+    assert!(
+        error.contains("Failed to send request") || error.contains("Request failed"),
+        "Error should indicate connection failure: {}",
+        error
+    );
+    println!("✓ Correctly handled invalid URL: {}", error);
+}
+
+#[tokio::test]
+async fn test_list_peers() {
+    if let Some(api_url) = get_available_api_url().await {
+        let result = list_peers(&api_url).await;
+
+        match result {
+            Ok(peers) => {
+                // Peers should be an array (even if empty)
+                assert!(peers.is_array(), "Peers should be a JSON array");
+                println!(
+                    "✓ Peers listed successfully: {} peers found",
+                    peers.as_array().unwrap().len()
+                );
+            }
+            Err(e) => {
+                println!(
+                    "⚠ List peers request failed (API might have changed): {}",
+                    e
+                );
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_list_peers: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_add_peer_validation() {
+    if let Some(api_url) = get_available_api_url().await {
+        // Test with an invalid peer address format
+        let invalid_peer = "invalid-peer-address";
+        let result = add_peer(&api_url, invalid_peer).await;
+
+        // This should either succeed (if the node accepts it) or fail with a validation error
+        match result {
+            Ok(response) => {
+                println!("✓ Add peer response: {:?}", response);
+            }
+            Err(e) => {
+                // Expected for invalid peer addresses
+                println!("✓ Correctly rejected invalid peer address: {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_add_peer_validation: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_list_selected_routes() {
+    if let Some(api_url) = get_available_api_url().await {
+        let result = list_selected_routes(&api_url).await;
+
+        match result {
+            Ok(routes) => {
+                // Routes should be an array or object
+                assert!(
+                    routes.is_array() || routes.is_object(),
+                    "Routes should be a JSON array or object"
+                );
+                println!("✓ Selected routes retrieved successfully");
+            }
+            Err(e) => {
+                println!("⚠ List selected routes request failed: {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_list_selected_routes: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_list_fallback_routes() {
+    if let Some(api_url) = get_available_api_url().await {
+        let result = list_fallback_routes(&api_url).await;
+
+        match result {
+            Ok(routes) => {
+                // Routes should be an array or object
+                assert!(
+                    routes.is_array() || routes.is_object(),
+                    "Routes should be a JSON array or object"
+                );
+                println!("✓ Fallback routes retrieved successfully");
+            }
+            Err(e) => {
+                println!("⚠ List fallback routes request failed: {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_list_fallback_routes: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_send_message_validation() {
+    if let Some(api_url) = get_available_api_url().await {
+        // Test message sending with invalid destination
+        let invalid_destination = "invalid-destination";
+        let topic = "test_topic";
+        let message = "test message";
+        let deadline = Some(Duration::from_secs(1));
+
+        let result = send_message(&api_url, invalid_destination, topic, message, deadline).await;
+
+        // This should fail with invalid destination
+        match result {
+            Ok(response) => {
+                // Some implementations might accept any destination format
+                println!("✓ Send message response: {:?}", response);
+            }
+            Err(e) => {
+                // Expected for invalid destinations
+                println!("✓ Correctly rejected invalid destination: {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_send_message_validation: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_receive_messages_timeout() {
+    if let Some(api_url) = get_available_api_url().await {
+        let topic = "non_existent_topic";
+        let deadline = Some(Duration::from_secs(1)); // Short timeout
+
+        let result = receive_messages(&api_url, topic, deadline).await;
+
+        match result {
+            Ok(messages) => {
+                // Should return empty or no messages for non-existent topic
+                println!("✓ Receive messages completed: {:?}", messages);
+            }
+            Err(e) => {
+                // Timeout or no messages is acceptable
+                println!("✓ Receive messages handled correctly: {}", e);
+            }
+        }
+    } else {
+        println!("⚠ Skipping test_receive_messages_timeout: No Mycelium node available");
+    }
+}
+
+#[tokio::test]
+async fn test_error_handling_malformed_url() {
+    let malformed_url = "not-a-url";
+    let result = get_node_info(malformed_url).await;
+
+    assert!(result.is_err(), "Should fail with malformed URL");
+    let error = result.unwrap_err();
+    assert!(
+        error.contains("Failed to send request"),
+        "Error should indicate request failure: {}",
+        error
+    );
+    println!("✓ Correctly handled malformed URL: {}", error);
+}
+
+#[tokio::test]
+async fn test_base64_encoding_in_messages() {
+    // Test that our message functions properly handle base64 encoding
+    // This is a unit test that doesn't require a running Mycelium node
+
+    let topic = "test/topic";
+    let message = "Hello, Mycelium!";
+
+    // Test base64 encoding directly
+    use base64::{engine::general_purpose, Engine as _};
+    let encoded_topic = general_purpose::STANDARD.encode(topic);
+    let encoded_message = general_purpose::STANDARD.encode(message);
+
+    assert!(
+        !encoded_topic.is_empty(),
+        "Encoded topic should not be empty"
+    );
+    assert!(
+        !encoded_message.is_empty(),
+        "Encoded message should not be empty"
+    );
+
+    // Verify we can decode back
+    let decoded_topic = general_purpose::STANDARD.decode(&encoded_topic).unwrap();
+    let decoded_message = general_purpose::STANDARD.decode(&encoded_message).unwrap();
+
+    assert_eq!(String::from_utf8(decoded_topic).unwrap(), topic);
+    assert_eq!(String::from_utf8(decoded_message).unwrap(), message);
+
+    println!("✓ Base64 encoding/decoding works correctly");
+}

packages/clients/myceliumclient/tests/rhai/01_mycelium_basic.rhai

@@ -0,0 +1,242 @@
+// Basic Mycelium functionality tests in Rhai
+//
+// This script tests the core Mycelium operations available through Rhai.
+// It's designed to work with or without a running Mycelium node.
+
+print("=== Mycelium Basic Functionality Tests ===");
+
+// Test configuration
+let test_api_url = "http://localhost:8989";
+let fallback_api_url = "http://localhost:7777";
+
+// Helper function to check if Mycelium is available
+fn is_mycelium_available(api_url) {
+    try {
+        mycelium_get_node_info(api_url);
+        return true;
+    } catch(err) {
+        return false;
+    }
+}
+
+// Find an available API URL
+let api_url = "";
+if is_mycelium_available(test_api_url) {
+    api_url = test_api_url;
+    print(`✓ Using primary API URL: ${api_url}`);
+} else if is_mycelium_available(fallback_api_url) {
+    api_url = fallback_api_url;
+    print(`✓ Using fallback API URL: ${api_url}`);
+} else {
+    print("⚠ No Mycelium node available - testing error handling only");
+    api_url = "http://localhost:99999"; // Intentionally invalid for error testing
+}
+
+// Test 1: Get Node Information
+print("\n--- Test 1: Get Node Information ---");
+try {
+    let node_info = mycelium_get_node_info(api_url);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected error but got success");
+        assert_true(false, "Should have failed with invalid URL");
+    } else {
+        print("✓ Node info retrieved successfully");
+        print(`  Node info type: ${type_of(node_info)}`);
+        
+        // Validate response structure
+        if type_of(node_info) == "map" {
+            print("✓ Node info is a proper object");
+            
+            // Check for common fields (at least one should exist)
+            let has_fields = node_info.contains("nodeSubnet") || 
+                           node_info.contains("nodePubkey") || 
+                           node_info.contains("peers") ||
+                           node_info.contains("routes");
+            
+            if has_fields {
+                print("✓ Node info contains expected fields");
+            } else {
+                print("⚠ Node info structure might have changed");
+            }
+        }
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+        assert_true(err.to_string().contains("Mycelium error"), "Error should be properly formatted");
+    } else {
+        print(`⚠ Unexpected error with available node: ${err}`);
+    }
+}
+
+// Test 2: List Peers
+print("\n--- Test 2: List Peers ---");
+try {
+    let peers = mycelium_list_peers(api_url);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected error but got success");
+        assert_true(false, "Should have failed with invalid URL");
+    } else {
+        print("✓ Peers listed successfully");
+        print(`  Peers type: ${type_of(peers)}`);
+        
+        if type_of(peers) == "array" {
+            print(`✓ Found ${peers.len()} peers`);
+            
+            // If we have peers, check their structure
+            if peers.len() > 0 {
+                let first_peer = peers[0];
+                print(`  First peer type: ${type_of(first_peer)}`);
+                
+                if type_of(first_peer) == "map" {
+                    print("✓ Peer has proper object structure");
+                }
+            }
+        } else {
+            print("⚠ Peers response is not an array");
+        }
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`⚠ Unexpected error listing peers: ${err}`);
+    }
+}
+
+// Test 3: Add Peer (with validation)
+print("\n--- Test 3: Add Peer Validation ---");
+try {
+    // Test with invalid peer address
+    let result = mycelium_add_peer(api_url, "invalid-peer-format");
+    
+    if api_url.contains("99999") {
+        print("✗ Expected connection error but got success");
+    } else {
+        print("✓ Add peer completed (validation depends on node implementation)");
+        print(`  Result type: ${type_of(result)}`);
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`✓ Peer validation error (expected): ${err}`);
+    }
+}
+
+// Test 4: List Selected Routes
+print("\n--- Test 4: List Selected Routes ---");
+try {
+    let routes = mycelium_list_selected_routes(api_url);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected error but got success");
+    } else {
+        print("✓ Selected routes retrieved successfully");
+        print(`  Routes type: ${type_of(routes)}`);
+        
+        if type_of(routes) == "array" {
+            print(`✓ Found ${routes.len()} selected routes`);
+        } else if type_of(routes) == "map" {
+            print("✓ Routes returned as object");
+        }
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`⚠ Error retrieving selected routes: ${err}`);
+    }
+}
+
+// Test 5: List Fallback Routes
+print("\n--- Test 5: List Fallback Routes ---");
+try {
+    let routes = mycelium_list_fallback_routes(api_url);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected error but got success");
+    } else {
+        print("✓ Fallback routes retrieved successfully");
+        print(`  Routes type: ${type_of(routes)}`);
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`⚠ Error retrieving fallback routes: ${err}`);
+    }
+}
+
+// Test 6: Send Message (validation)
+print("\n--- Test 6: Send Message Validation ---");
+try {
+    let result = mycelium_send_message(api_url, "invalid-destination", "test_topic", "test message", -1);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected connection error but got success");
+    } else {
+        print("✓ Send message completed (validation depends on node implementation)");
+        print(`  Result type: ${type_of(result)}`);
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`✓ Message validation error (expected): ${err}`);
+    }
+}
+
+// Test 7: Receive Messages (timeout test)
+print("\n--- Test 7: Receive Messages Timeout ---");
+try {
+    // Use short timeout to avoid long waits
+    let messages = mycelium_receive_messages(api_url, "non_existent_topic", 1);
+    
+    if api_url.contains("99999") {
+        print("✗ Expected connection error but got success");
+    } else {
+        print("✓ Receive messages completed");
+        print(`  Messages type: ${type_of(messages)}`);
+        
+        if type_of(messages) == "array" {
+            print(`✓ Received ${messages.len()} messages`);
+        } else {
+            print("✓ Messages returned as object");
+        }
+    }
+} catch(err) {
+    if api_url.contains("99999") {
+        print("✓ Correctly handled connection error");
+    } else {
+        print(`✓ Receive timeout handled correctly: ${err}`);
+    }
+}
+
+// Test 8: Parameter Validation
+print("\n--- Test 8: Parameter Validation ---");
+
+// Test empty API URL
+try {
+    mycelium_get_node_info("");
+    print("✗ Should have failed with empty API URL");
+} catch(err) {
+    print("✓ Correctly rejected empty API URL");
+}
+
+// Test negative timeout handling
+try {
+    mycelium_receive_messages(api_url, "test_topic", -1);
+    if api_url.contains("99999") {
+        print("✗ Expected connection error");
+    } else {
+        print("✓ Negative timeout handled (treated as no timeout)");
+    }
+} catch(err) {
+    print("✓ Timeout parameter handled correctly");
+}
+
+print("\n=== Mycelium Basic Tests Completed ===");
+print("All core Mycelium functions are properly registered and handle errors correctly.");

packages/clients/myceliumclient/tests/rhai/run_all_tests.rhai

@@ -0,0 +1,174 @@
+// Mycelium Rhai Test Runner
+//
+// This script runs all Mycelium-related Rhai tests and reports results.
+// It includes simplified versions of the individual tests to avoid dependency issues.
+
+print("=== Mycelium Rhai Test Suite ===");
+print("Running comprehensive tests for Mycelium Rhai integration...\n");
+
+let total_tests = 0;
+let passed_tests = 0;
+let failed_tests = 0;
+let skipped_tests = 0;
+
+// Test 1: Function Registration
+print("Test 1: Function Registration");
+total_tests += 1;
+try {
+    // Test that all mycelium functions are registered
+    let invalid_url = "http://localhost:99999";
+    let all_functions_exist = true;
+
+    try { mycelium_get_node_info(invalid_url); } catch(err) {
+        if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
+    }
+
+    try { mycelium_list_peers(invalid_url); } catch(err) {
+        if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
+    }
+
+    try { mycelium_send_message(invalid_url, "dest", "topic", "msg", -1); } catch(err) {
+        if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
+    }
+
+    if all_functions_exist {
+        passed_tests += 1;
+        print("✓ PASSED: All mycelium functions are registered");
+    } else {
+        failed_tests += 1;
+        print("✗ FAILED: Some mycelium functions are missing");
+    }
+} catch(err) {
+    failed_tests += 1;
+    print(`✗ ERROR: Function registration test failed - ${err}`);
+}
+
+// Test 2: Error Handling
+print("\nTest 2: Error Handling");
+total_tests += 1;
+try {
+    mycelium_get_node_info("http://localhost:99999");
+    failed_tests += 1;
+    print("✗ FAILED: Should have failed with connection error");
+} catch(err) {
+    if err.to_string().contains("Mycelium error") {
+        passed_tests += 1;
+        print("✓ PASSED: Error handling works correctly");
+    } else {
+        failed_tests += 1;
+        print(`✗ FAILED: Unexpected error format - ${err}`);
+    }
+}
+
+// Test 3: Parameter Validation
+print("\nTest 3: Parameter Validation");
+total_tests += 1;
+try {
+    mycelium_get_node_info("");
+    failed_tests += 1;
+    print("✗ FAILED: Should have failed with empty API URL");
+} catch(err) {
+    passed_tests += 1;
+    print("✓ PASSED: Parameter validation works correctly");
+}
+
+// Test 4: Timeout Parameter Handling
+print("\nTest 4: Timeout Parameter Handling");
+total_tests += 1;
+try {
+    let invalid_url = "http://localhost:99999";
+
+    // Test negative timeout (should be treated as no timeout)
+    try {
+        mycelium_receive_messages(invalid_url, "topic", -1);
+        failed_tests += 1;
+        print("✗ FAILED: Should have failed with connection error");
+    } catch(err) {
+        if err.to_string().contains("Mycelium error") {
+            passed_tests += 1;
+            print("✓ PASSED: Timeout parameter handling works correctly");
+        } else {
+            failed_tests += 1;
+            print(`✗ FAILED: Unexpected error - ${err}`);
+        }
+    }
+} catch(err) {
+    failed_tests += 1;
+    print(`✗ ERROR: Timeout test failed - ${err}`);
+}
+
+// Check if Mycelium is available for integration tests
+let test_api_url = "http://localhost:8989";
+let fallback_api_url = "http://localhost:7777";
+let available_api_url = "";
+
+try {
+    mycelium_get_node_info(test_api_url);
+    available_api_url = test_api_url;
+} catch(err) {
+    try {
+        mycelium_get_node_info(fallback_api_url);
+        available_api_url = fallback_api_url;
+    } catch(err2) {
+        // No Mycelium node available
+    }
+}
+
+if available_api_url != "" {
+    print(`\n✓ Mycelium node available at: ${available_api_url}`);
+
+    // Test 5: Get Node Info
+    print("\nTest 5: Get Node Info");
+    total_tests += 1;
+    try {
+        let node_info = mycelium_get_node_info(available_api_url);
+
+        if type_of(node_info) == "map" {
+            passed_tests += 1;
+            print("✓ PASSED: Node info retrieved successfully");
+        } else {
+            failed_tests += 1;
+            print("✗ FAILED: Node info should be an object");
+        }
+    } catch(err) {
+        failed_tests += 1;
+        print(`✗ ERROR: Node info test failed - ${err}`);
+    }
+
+    // Test 6: List Peers
+    print("\nTest 6: List Peers");
+    total_tests += 1;
+    try {
+        let peers = mycelium_list_peers(available_api_url);
+
+        if type_of(peers) == "array" {
+            passed_tests += 1;
+            print("✓ PASSED: Peers listed successfully");
+        } else {
+            failed_tests += 1;
+            print("✗ FAILED: Peers should be an array");
+        }
+    } catch(err) {
+        failed_tests += 1;
+        print(`✗ ERROR: List peers test failed - ${err}`);
+    }
+} else {
+    print("\n⚠ No Mycelium node available - skipping integration tests");
+    skipped_tests += 2; // Skip node info and list peers tests
+    total_tests += 2;
+}
+
+// Print final results
+print("\n=== Test Results ===");
+print(`Total Tests: ${total_tests}`);
+print(`Passed: ${passed_tests}`);
+print(`Failed: ${failed_tests}`);
+print(`Skipped: ${skipped_tests}`);
+
+if failed_tests == 0 {
+    print("\n✓ All tests passed!");
+} else {
+    print(`\n✗ ${failed_tests} test(s) failed.`);
+}
+
+print("\n=== Mycelium Rhai Test Suite Completed ===");

packages/clients/myceliumclient/tests/rhai_integration_tests.rs

@@ -0,0 +1,313 @@
+//! Rhai integration tests for Mycelium module
+//!
+//! These tests validate the Rhai wrapper functions and ensure proper
+//! integration between Rust and Rhai for Mycelium operations.
+
+use rhai::{Engine, EvalAltResult};
+use sal_mycelium::rhai::*;
+
+#[cfg(test)]
+mod rhai_integration_tests {
+    use super::*;
+
+    fn create_test_engine() -> Engine {
+        let mut engine = Engine::new();
+        register_mycelium_module(&mut engine).expect("Failed to register mycelium module");
+        engine
+    }
+
+    #[test]
+    fn test_rhai_module_registration() {
+        let engine = create_test_engine();
+
+        // Test that the functions are registered by checking if they exist
+        let script = r#"
+            // Test that all mycelium functions are available
+            let functions_exist = true;
+            
+            // We can't actually call these without a server, but we can verify they're registered
+            // by checking that the engine doesn't throw "function not found" errors
+            functions_exist
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_get_node_info_function_exists() {
+        let engine = create_test_engine();
+
+        // Test that mycelium_get_node_info function is registered
+        let script = r#"
+            // This will fail with connection error, but proves the function exists
+            try {
+                mycelium_get_node_info("http://localhost:99999");
+                false; // Should not reach here
+            } catch(err) {
+                // Function exists but failed due to connection - this is expected
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        if let Err(ref e) = result {
+            println!("Script evaluation error: {}", e);
+        }
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_list_peers_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_list_peers("http://localhost:99999");
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_add_peer_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_add_peer("http://localhost:99999", "tcp://example.com:9651");
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_remove_peer_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_remove_peer("http://localhost:99999", "peer_id");
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_list_selected_routes_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_list_selected_routes("http://localhost:99999");
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_list_fallback_routes_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_list_fallback_routes("http://localhost:99999");
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_send_message_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_send_message("http://localhost:99999", "destination", "topic", "message", -1);
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_mycelium_receive_messages_function_exists() {
+        let engine = create_test_engine();
+
+        let script = r#"
+            try {
+                mycelium_receive_messages("http://localhost:99999", "topic", 1);
+                return false;
+            } catch(err) {
+                return err.to_string().contains("Mycelium error");
+            }
+        "#;
+
+        let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn test_parameter_validation() {
+        let engine = create_test_engine();
+
+        // Test that functions handle parameter validation correctly
+        let script = r#"
+            let test_results = [];
+            
+            // Test empty API URL
+            try {
+                mycelium_get_node_info("");
+                test_results.push(false);
+            } catch(err) {
+                test_results.push(true); // Expected to fail
+            }
+            
+            // Test empty peer address
+            try {
+                mycelium_add_peer("http://localhost:8989", "");
+                test_results.push(false);
+            } catch(err) {
+                test_results.push(true); // Expected to fail
+            }
+            
+            // Test negative timeout handling
+            try {
+                mycelium_receive_messages("http://localhost:99999", "topic", -1);
+                test_results.push(false);
+            } catch(err) {
+                // Should handle negative timeout gracefully
+                test_results.push(err.to_string().contains("Mycelium error"));
+            }
+            
+            test_results
+        "#;
+
+        let result: Result<rhai::Array, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        let results = result.unwrap();
+
+        // All parameter validation tests should pass
+        for (i, result) in results.iter().enumerate() {
+            assert_eq!(
+                result.as_bool().unwrap_or(false),
+                true,
+                "Parameter validation test {} failed",
+                i
+            );
+        }
+    }
+
+    #[test]
+    fn test_error_message_format() {
+        let engine = create_test_engine();
+
+        // Test that error messages are properly formatted
+        let script = r#"
+            try {
+                mycelium_get_node_info("http://localhost:99999");
+                return "";
+            } catch(err) {
+                let error_str = err.to_string();
+                // Should contain "Mycelium error:" prefix
+                if error_str.contains("Mycelium error:") {
+                    return "correct_format";
+                } else {
+                    return error_str;
+                }
+            }
+        "#;
+
+        let result: Result<String, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), "correct_format");
+    }
+
+    #[test]
+    fn test_timeout_parameter_handling() {
+        let engine = create_test_engine();
+
+        // Test different timeout parameter values
+        let script = r#"
+            let timeout_tests = [];
+            
+            // Test positive timeout
+            try {
+                mycelium_receive_messages("http://localhost:99999", "topic", 5);
+                timeout_tests.push(false);
+            } catch(err) {
+                timeout_tests.push(err.to_string().contains("Mycelium error"));
+            }
+            
+            // Test zero timeout
+            try {
+                mycelium_receive_messages("http://localhost:99999", "topic", 0);
+                timeout_tests.push(false);
+            } catch(err) {
+                timeout_tests.push(err.to_string().contains("Mycelium error"));
+            }
+            
+            // Test negative timeout (should be treated as no timeout)
+            try {
+                mycelium_receive_messages("http://localhost:99999", "topic", -1);
+                timeout_tests.push(false);
+            } catch(err) {
+                timeout_tests.push(err.to_string().contains("Mycelium error"));
+            }
+            
+            timeout_tests
+        "#;
+
+        let result: Result<rhai::Array, Box<EvalAltResult>> = engine.eval(script);
+        assert!(result.is_ok());
+        let results = result.unwrap();
+
+        // All timeout tests should handle the connection error properly
+        for (i, result) in results.iter().enumerate() {
+            assert_eq!(
+                result.as_bool().unwrap_or(false),
+                true,
+                "Timeout test {} failed",
+                i
+            );
+        }
+    }
+}

packages/clients/postgresclient/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "sal-postgresclient"
+version = "0.1.0"
+edition = "2021"
+authors = ["PlanetFirst <info@incubaid.com>"]
+description = "SAL PostgreSQL Client - PostgreSQL client wrapper with connection management and Rhai integration"
+repository = "https://git.threefold.info/herocode/sal"
+license = "Apache-2.0"
+keywords = ["postgresql", "database", "client", "connection-pool", "rhai"]
+categories = ["database", "api-bindings"]
+
+[dependencies]
+# PostgreSQL client dependencies
+postgres = { workspace = true }
+postgres-types = { workspace = true }
+tokio-postgres = { workspace = true }
+
+# Connection pooling
+r2d2 = { workspace = true }
+r2d2_postgres = { workspace = true }
+
+# Utility dependencies
+lazy_static = { workspace = true }
+thiserror = { workspace = true }
+
+# Rhai scripting support
+rhai = { workspace = true }
+
+# SAL dependencies
+sal-virt = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
+tokio-test = { workspace = true }

packages/clients/postgresclient/README.md

@@ -1,6 +1,15 @@
-# PostgreSQL Client Module
+# SAL PostgreSQL Client (`sal-postgresclient`)
 
-The PostgreSQL client module provides a simple and efficient way to interact with PostgreSQL databases in Rust. It offers connection management, query execution, and a builder pattern for flexible configuration.
+The SAL PostgreSQL Client (`sal-postgresclient`) is an independent package that provides a simple and efficient way to interact with PostgreSQL databases in Rust. It offers connection management, query execution, a builder pattern for flexible configuration, and PostgreSQL installer functionality using nerdctl.
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+sal-postgresclient = "0.1.0"
+```
 
 ## Features
 
@@ -9,13 +18,15 @@ The PostgreSQL client module provides a simple and efficient way to interact wit
 - **Builder Pattern**: Flexible configuration with authentication support
 - **Environment Variable Support**: Easy configuration through environment variables
 - **Thread Safety**: Safe to use in multi-threaded applications
+- **PostgreSQL Installer**: Install and configure PostgreSQL using nerdctl containers
+- **Rhai Integration**: Scripting support for PostgreSQL operations
 
 ## Usage
 
 ### Basic Usage
 
 ```rust
-use sal::postgresclient::{execute, query, query_one};
+use sal_postgresclient::{execute, query, query_one};
 
 // Execute a query
 let create_table_query = "CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT)";
@@ -38,7 +49,7 @@ println!("User: {} (ID: {})", name, id);
 The module manages connections automatically, but you can also reset the connection if needed:
 
 ```rust
-use sal::postgresclient::reset;
+use sal_postgresclient::reset;
 
 // Reset the PostgreSQL client connection
 reset().expect("Failed to reset connection");
@@ -49,7 +60,7 @@ reset().expect("Failed to reset connection");
 The module provides a builder pattern for flexible configuration:
 
 ```rust
-use sal::postgresclient::{PostgresConfigBuilder, with_config};
+use sal_postgresclient::{PostgresConfigBuilder, with_config};
 
 // Create a configuration builder
 let config = PostgresConfigBuilder::new()
@@ -66,6 +77,53 @@ let config = PostgresConfigBuilder::new()
 let client = with_config(config).expect("Failed to connect");
 ```
 
+### PostgreSQL Installer
+
+The package includes a PostgreSQL installer that can set up PostgreSQL using nerdctl containers:
+
+```rust
+use sal_postgresclient::{PostgresInstallerConfig, install_postgres};
+
+// Create installer configuration
+let config = PostgresInstallerConfig::new()
+    .container_name("my-postgres")
+    .version("15")
+    .port(5433)
+    .username("myuser")
+    .password("mypassword")
+    .data_dir("/path/to/data")
+    .persistent(true);
+
+// Install PostgreSQL
+let container = install_postgres(config).expect("Failed to install PostgreSQL");
+```
+
+### Rhai Integration
+
+The package provides Rhai scripting support for PostgreSQL operations:
+
+```rust
+use sal_postgresclient::rhai::register_postgresclient_module;
+use rhai::Engine;
+
+let mut engine = Engine::new();
+register_postgresclient_module(&mut engine).expect("Failed to register PostgreSQL module");
+
+// Now you can use PostgreSQL functions in Rhai scripts
+let script = r#"
+    // Connect to PostgreSQL
+    let connected = pg_connect();
+
+    // Execute a query
+    let rows_affected = pg_execute("CREATE TABLE test (id SERIAL PRIMARY KEY, name TEXT)");
+
+    // Query data
+    let results = pg_query("SELECT * FROM test");
+"#;
+
+engine.eval::<()>(script).expect("Failed to execute script");
+```
+
 ## Configuration
 
 ### Environment Variables
@@ -122,7 +180,7 @@ host=localhost port=5432 user=postgres dbname=postgres application_name=my-app c
 The module uses the `postgres::Error` type for error handling:
 
 ```rust
-use sal::postgresclient::{query, query_one};
+use sal_postgresclient::{query, query_one};
 
 // Handle errors
 match query("SELECT * FROM users", &[]) {
@@ -154,7 +212,7 @@ The PostgreSQL client module is designed to be thread-safe. It uses `Arc` and `M
 ### Basic CRUD Operations
 
 ```rust
-use sal::postgresclient::{execute, query, query_one};
+use sal_postgresclient::{execute, query, query_one};
 
 // Create
 let create_query = "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id";
@@ -181,7 +239,7 @@ let affected = execute(delete_query, &[&id]).expect("Failed to delete user");
 Transactions are not directly supported by the module, but you can use the PostgreSQL client to implement them:
 
 ```rust
-use sal::postgresclient::{execute, query};
+use sal_postgresclient::{execute, query};
 
 // Start a transaction
 execute("BEGIN", &[]).expect("Failed to start transaction");

packages/clients/postgresclient/src/installer.rs

@@ -10,7 +10,7 @@ use std::process::Command;
 use std::thread;
 use std::time::Duration;
 
-use crate::virt::nerdctl::Container;
+use sal_virt::nerdctl::Container;
 use std::error::Error;
 use std::fmt;
 

packages/clients/postgresclient/src/lib.rs

@@ -0,0 +1,41 @@
+//! SAL PostgreSQL Client
+//!
+//! This crate provides a PostgreSQL client for interacting with PostgreSQL databases.
+//! It offers connection management, query execution, and a builder pattern for flexible configuration.
+//!
+//! ## Features
+//!
+//! - **Connection Management**: Automatic connection handling and reconnection
+//! - **Query Execution**: Simple API for executing queries and fetching results
+//! - **Builder Pattern**: Flexible configuration with authentication support
+//! - **Environment Variable Support**: Easy configuration through environment variables
+//! - **Thread Safety**: Safe to use in multi-threaded applications
+//! - **PostgreSQL Installer**: Install and configure PostgreSQL using nerdctl
+//! - **Rhai Integration**: Scripting support for PostgreSQL operations
+//!
+//! ## Usage
+//!
+//! ```rust,no_run
+//! use sal_postgresclient::{execute, query, query_one};
+//!
+//! fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     // Execute a query
+//!     let rows_affected = execute("CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)", &[])?;
+//!
+//!     // Query data
+//!     let rows = query("SELECT * FROM users", &[])?;
+//!
+//!     // Query single row
+//!     let row = query_one("SELECT * FROM users WHERE id = $1", &[&1])?;
+//!
+//!     Ok(())
+//! }
+//! ```
+
+mod installer;
+mod postgresclient;
+pub mod rhai;
+
+// Re-export the public API
+pub use installer::*;
+pub use postgresclient::*;

packages/clients/postgresclient/src/postgresclient.rs

@@ -242,8 +242,8 @@ pub struct PostgresClientWrapper {
 /// or rolled back if an error occurs.
 ///
 /// Example:
-/// ```
+/// ```no_run
-/// use sal::postgresclient::{transaction, QueryParams};
+/// use sal_postgresclient::{transaction, QueryParams};
 ///
 /// let result = transaction(|client| {
 ///     // Execute queries within the transaction
@@ -291,8 +291,8 @@ where
 /// or rolled back if an error occurs.
 ///
 /// Example:
-/// ```
+/// ```no_run
-/// use sal::postgresclient::{transaction_with_pool, QueryParams};
+/// use sal_postgresclient::{transaction_with_pool, QueryParams};
 ///
 /// let result = transaction_with_pool(|client| {
 ///     // Execute queries within the transaction
@@ -795,7 +795,7 @@ pub fn query_opt_with_pool_params(
 ///
 /// Example:
 /// ```no_run
-/// use sal::postgresclient::notify;
+/// use sal_postgresclient::notify;
 ///
 /// notify("my_channel", "Hello, world!").expect("Failed to send notification");
 /// ```
@@ -811,7 +811,7 @@ pub fn notify(channel: &str, payload: &str) -> Result<(), PostgresError> {
 ///
 /// Example:
 /// ```no_run
-/// use sal::postgresclient::notify_with_pool;
+/// use sal_postgresclient::notify_with_pool;
 ///
 /// notify_with_pool("my_channel", "Hello, world!").expect("Failed to send notification");
 /// ```