feat: Add SSH remote terminal support to web interface (#352)

Adds SSH-based remote terminal access to the web chat interface. Users
can now connect to remote servers via SSH, with auto-installation of the
infer binary. Includes a Docker Compose example demonstrating both local
and remote modes.

## Summary of Changes

This PR enables users to:
1. Connect to remote servers via SSH from the web terminal
2. Auto-install infer binary on remote servers when missing
3. Switch between local and remote servers via a dropdown
4. Use portable Linux binaries (CGO-free) for better compatibility
5. Test with a complete Docker Compose example

## Key Features

### SSH Remote Mode
- Added ability to connect to remote servers via SSH from the web
terminal
- Secure authentication with SSH keys or passwords
- Persistent connections with session management

### Auto-installation
- Automatically installs `infer` binary on remote servers if missing
- Supports multiple architectures and operating systems
- Fallback mechanisms for installation failures

### Web Terminal Enhancements
- Added server selection dropdown in the web interface
- Support for multiple concurrent server connections
- Improved error handling and user feedback

### Portable Linux Builds
- Changed Linux builds to use CGO_ENABLED=0 for maximum compatibility
- Statically linked binaries that work on any Linux distribution
- Reduced dependency requirements on target systems

### Docker Compose Example
- Complete example with local + remote Ubuntu server setup
- Environment configuration templates
- Step-by-step documentation in README.md

## Technical Details

### New Files:
- `internal/web/ssh_client.go` - SSH client implementation
- `internal/web/ssh_session.go` - SSH session management
- `internal/web/remote_installer.go` - Remote binary installation
- `examples/web-terminal/` - Complete example setup

### Modified Files:
- `cmd/chat.go` - Added SSH mode flag and configuration
- `internal/web/server.go` - Enhanced web server with SSH support
- `internal/web/session_manager.go` - Multi-server session management
- `internal/web/static/app.js` - Frontend server selection UI
- `internal/web/templates/index.html` - Updated HTML template
- Build configuration updates for portable binaries

## Testing

The included Docker Compose example provides a complete test
environment:
- Local infer instance for direct testing
- Remote Ubuntu server for SSH testing
- Pre-configured environment variables
- Step-by-step setup instructions

## Compatibility

- Backward compatible with existing local mode
- Works with any SSH-compatible server (Linux, macOS, BSD)
- Supports both password and key-based authentication
- Portable binaries work on glibc and musl-based systems

---------

Signed-off-by: Eden Reich <[email protected]>
Co-authored-by: semantic-release-bot <[email protected]>

Author: edenreich

.flox/env/manifest.lock

@@ -29,7 +29,7 @@ ripgrep.version = "^15.1.0"
 markdownlint-cli.pkg-path = "markdownlint-cli"
 markdownlint-cli.version = "^0.47.0"
 claude-code.pkg-path = "claude-code"
-claude-code.version = "^2.0.74"
+claude-code.version = "^2.0.76"
 docker.pkg-path = "docker"
 docker.version = "^29.1.2"
 docker-compose.pkg-path = "docker-compose"

.flox/env/manifest.toml

@@ -56,22 +56,22 @@ jobs:
           echo "commit=$COMMIT" >> $GITHUB_OUTPUT
           echo "date=$DATE" >> $GITHUB_OUTPUT
 
-      - name: Build binary (Linux in Alpine container)
+      - name: Build binary (Linux portable - pure Go, no CGO dependencies)
         if: matrix.goos == 'linux'
         run: |
           docker run --rm \
             -v $PWD:/workspace \
             -w /workspace \
-            -e CGO_ENABLED=1 \
+            -e CGO_ENABLED=0 \
             golang:1.25-alpine3.23 \
-            sh -c "apk add --no-cache gcc musl-dev sqlite-dev && go build -tags libsqlite3 -ldflags '-w -s -X github.com/inference-gateway/cli/cmd.version=${{ steps.version.outputs.version }} -X github.com/inference-gateway/cli/cmd.commit=${{ steps.version.outputs.commit }} -X github.com/inference-gateway/cli/cmd.date=${{ steps.version.outputs.date }}' -o infer-${{ matrix.goos }}-${{ matrix.goarch }} ."
+            sh -c "go build -ldflags '-w -s -X github.com/inference-gateway/cli/cmd.version=${{ steps.version.outputs.version }} -X github.com/inference-gateway/cli/cmd.commit=${{ steps.version.outputs.commit }} -X github.com/inference-gateway/cli/cmd.date=${{ steps.version.outputs.date }}' -o infer-${{ matrix.goos }}-${{ matrix.goarch }} ."
 
-      - name: Build binary (macOS native)
+      - name: Build binary (macOS with CGO for clipboard image support)
         if: matrix.goos == 'darwin'
         env:
           CGO_ENABLED: ${{ matrix.cgo }}
         run: |
-          go build -tags libsqlite3 -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version=${{ steps.version.outputs.version }} -X github.com/inference-gateway/cli/cmd.commit=${{ steps.version.outputs.commit }} -X github.com/inference-gateway/cli/cmd.date=${{ steps.version.outputs.date }}" -o infer-${{ matrix.goos }}-${{ matrix.goarch }} .
+          go build -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version=${{ steps.version.outputs.version }} -X github.com/inference-gateway/cli/cmd.commit=${{ steps.version.outputs.commit }} -X github.com/inference-gateway/cli/cmd.date=${{ steps.version.outputs.date }}" -o infer-${{ matrix.goos }}-${{ matrix.goarch }} .
 
       - name: Upload artifact
         uses: actions/upload-artifact@v5

.github/workflows/artifacts.yml

@@ -97,17 +97,9 @@ jobs:
         go-version-file: 'go.mod'
         cache: true
 
-    - name: Install build dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y gcc libsqlite3-dev
-
     - name: Build project
-      env:
-        CGO_ENABLED: 1
       run: |
         go build \
-          -tags libsqlite3 \
           -ldflags "\
             -w -s \
             -X github.com/inference-gateway/cli/cmd.version=${{ github.ref_name }} \
@@ -129,12 +121,5 @@ jobs:
         go-version-file: 'go.mod'
         cache: true
 
-    - name: Install build dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y gcc libsqlite3-dev
-
     - name: Run tests
-      env:
-        CGO_ENABLED: 1
-      run: go test -tags libsqlite3 ./...
+      run: go test ./...

.github/workflows/ci.yml

@@ -249,6 +249,12 @@ agent:
     - If accepted, YOU will execute this plan. Make it specific and actionable!
     - Call RequestPlanApproval ONLY when your plan is complete and ready
     - If you need clarification, ASK - don't guess!
+  system_prompt_remote: |-
+    Remote system administration agent. You are operating on a remote machine via SSH.
+
+    FOCUS: System operations, service management, monitoring, diagnostics, and infrastructure tasks.
+
+    CONTEXT: This is a shared system environment, not a project workspace. Users may be managing servers, containers, services, or general infrastructure.
   system_reminders:
     enabled: true
     interval: 4
@@ -625,3 +631,10 @@ web:
   port: 3000
   host: localhost
   session_inactivity_mins: 5
+  ssh:
+    enabled: false
+    use_ssh_config: true
+    known_hosts_path: ~/.ssh/known_hosts
+    auto_install: true
+    install_version: latest
+  servers: []

.infer/config.yaml

@@ -13,7 +13,7 @@ The project uses Clean Architecture with domain-driven design patterns.
 ### Development Commands
 
 ```bash
-# Build the binary
+# Build the binary (pure Go, no CGO required)
 task build
 
 # Run all tests
@@ -33,6 +33,9 @@ task check
 
 # Complete development workflow (format, build, test)
 task dev
+
+# Verify dependencies
+task verify:deps
 ```
 
 ### Module Management
@@ -715,7 +718,7 @@ Key third-party libraries:
 - **Lipgloss**: Styling for terminal output
 - **go-redis**: Redis client for storage backend
 - **lib/pq**: PostgreSQL driver
-- **modernc.org/sqlite**: CGO-free SQLite driver
+- **modernc.org/sqlite**: Pure Go SQLite driver (no CGO required)
 - **metoro-io/mcp-golang**: MCP (Model Context Protocol) client library
 
 ## Development Environment

CHANGELOG.md

@@ -19,13 +19,7 @@ tasks:
   build:
     desc: Build the CLI binary
     cmds:
-      - |
-        if ! command -v gcc >/dev/null 2>&1 && ! command -v clang >/dev/null 2>&1; then
-          echo "ERROR: C compiler not found. Required for SQLite support."
-          echo "Install: build-essential (Linux) or Xcode CLI Tools (macOS)"
-          exit 1
-        fi
-      - CGO_ENABLED=1 go build -tags libsqlite3 -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o {{.BINARY_NAME}} {{.MAIN_PACKAGE}}
+      - go build -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o {{.BINARY_NAME}} {{.MAIN_PACKAGE}}
     sources:
       - "**/*.go"
       - go.mod
@@ -36,7 +30,7 @@ tasks:
   install:
     desc: Install the CLI from source
     cmds:
-      - CGO_ENABLED=1 go build -tags libsqlite3 -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o $(go env GOPATH)/bin/{{.BINARY_NAME}} {{.MAIN_PACKAGE}}
+      - go build -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o $(go env GOPATH)/bin/{{.BINARY_NAME}} {{.MAIN_PACKAGE}}
 
   clean:
     desc: Clean build artifacts
@@ -47,17 +41,17 @@ tasks:
   test:
     desc: Run all tests
     cmds:
-      - CGO_ENABLED=1 go test -tags libsqlite3 ./...
+      - go test ./...
 
   test:verbose:
     desc: Run tests with verbose output
     cmds:
-      - CGO_ENABLED=1 go test -tags libsqlite3 -v ./...
+      - go test -v ./...
 
   test:coverage:
     desc: Run tests with coverage report
     cmds:
-      - CGO_ENABLED=1 go test -tags libsqlite3 -cover ./...
+      - go test -cover ./...
 
   lint:
     desc: Run linter (requires golangci-lint)
@@ -85,35 +79,18 @@ tasks:
     cmds:
       - go mod download
 
-  verify:cgo:
-    desc: Verify CGO and SQLite dependencies
+  verify:deps:
+    desc: Verify Go dependencies
     cmds:
       - |
-        echo "Checking C compiler..."
-        if command -v gcc >/dev/null 2>&1; then
-          echo "✓ GCC found: $(gcc --version | head -n1)"
-        elif command -v clang >/dev/null 2>&1; then
-          echo "✓ Clang found: $(clang --version | head -n1)"
-        else
-          echo "✗ No C compiler found"
-          echo "Install: build-essential (Linux) or Xcode CLI Tools (macOS)"
-          exit 1
-        fi
-
-        echo "Checking SQLite library..."
-        if pkg-config --exists sqlite3 2>/dev/null; then
-          echo "✓ SQLite found: $(pkg-config --modversion sqlite3)"
-        else
-          echo "⚠ SQLite not detected via pkg-config (may still work if installed)"
-        fi
-
-        echo "Checking CGO..."
-        CGO_STATUS=$(go env CGO_ENABLED)
-        if [ "$CGO_STATUS" = "1" ]; then
-          echo "✓ CGO enabled"
-        else
-          echo "⚠ CGO disabled (will be enabled for build tasks)"
-        fi
+        echo "Checking Go version..."
+        go version
+        echo ""
+        echo "Checking dependencies..."
+        go mod verify
+        echo "✓ All dependencies verified"
+        echo ""
+        echo "Note: This CLI uses pure Go dependencies (no CGO required)"
 
   run:
     desc: Run the CLI locally
@@ -151,18 +128,15 @@ tasks:
       - test
 
   release:build:
-    desc: Build release binary for current platform only (multi-platform builds use GitHub Actions with native runners)
+    desc: Build release binary for current platform only
     cmds:
       - mkdir -p dist
       - |
-        echo "Building for native platform only..."
+        echo "Building for native platform..."
         GOOS=$(go env GOOS)
         GOARCH=$(go env GOARCH)
-        CGO_ENABLED=1 go build -tags libsqlite3 -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o dist/{{.BINARY_NAME}}-${GOOS}-${GOARCH} {{.MAIN_PACKAGE}}
+        go build -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o dist/{{.BINARY_NAME}}-${GOOS}-${GOARCH} {{.MAIN_PACKAGE}}
         echo "✓ Built dist/{{.BINARY_NAME}}-${GOOS}-${GOARCH}"
-        echo ""
-        echo "Note: Cross-platform builds with dynamic SQLite linking require native runners."
-        echo "Use GitHub Actions for multi-platform releases."
       - cd dist && sha256sum {{.BINARY_NAME}}-* > checksums.txt
       - |
         if command -v cosign >/dev/null 2>&1; then
@@ -173,18 +147,38 @@ tasks:
         fi
 
   release:build:darwin:
-    desc: Build macOS binary with CGO enabled (for clipboard image support)
+    desc: Build macOS binary
+    vars:
+      GOARCH:
+        sh: go env GOARCH
+    cmds:
+      - mkdir -p dist
+      - GOOS=darwin GOARCH={{.GOARCH}} go build -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o dist/{{.BINARY_NAME}}-darwin-{{.GOARCH}} {{.MAIN_PACKAGE}}
+
+  release:build:linux:
+    desc: Build portable Linux binary using Docker
     vars:
       GOARCH:
         sh: go env GOARCH
     cmds:
       - mkdir -p dist
-      - CGO_ENABLED=1 GOOS=darwin GOARCH={{.GOARCH}} go build -tags libsqlite3 -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" -o dist/{{.BINARY_NAME}}-darwin-{{.GOARCH}} {{.MAIN_PACKAGE}}
+      - |
+        echo "Building portable Linux binary using Docker..."
+        docker run --rm \
+          -v "{{.PWD}}":/build \
+          -w /build \
+          golang:1.25-alpine \
+          sh -c 'CGO_ENABLED=0 GOOS=linux GOARCH={{.GOARCH}} \
+            go build \
+            -ldflags "-w -s -X github.com/inference-gateway/cli/cmd.version={{.VERSION}} -X github.com/inference-gateway/cli/cmd.commit={{.COMMIT}} -X github.com/inference-gateway/cli/cmd.date={{.DATE}}" \
+            -o dist/{{.BINARY_NAME}}-linux-{{.GOARCH}} .'
+        echo "✓ Built portable dist/{{.BINARY_NAME}}-linux-{{.GOARCH}} (pure Go, all storage backends supported)"
 
   container:build:
     desc: Build container image locally for testing
     cmds:
       - task: release:build
+      - task: release:build:linux
       - |
         docker build \
           --build-context binaries=dist/ \

CLAUDE.md

@@ -42,6 +42,34 @@ and have a conversational interface with the inference gateway.`,
 			if cmd.Flags().Changed("port") {
 				cfg.Web.Port, _ = cmd.Flags().GetInt("port")
 			}
+			if cmd.Flags().Changed("host") {
+				cfg.Web.Host, _ = cmd.Flags().GetString("host")
+			}
+
+			// SSH remote mode flags
+			if cmd.Flags().Changed("ssh-host") {
+				cfg.Web.SSH.Enabled = true
+				sshHost, _ := cmd.Flags().GetString("ssh-host")
+				sshUser, _ := cmd.Flags().GetString("ssh-user")
+				sshPort, _ := cmd.Flags().GetInt("ssh-port")
+				sshCommand, _ := cmd.Flags().GetString("ssh-command")
+				noInstall, _ := cmd.Flags().GetBool("ssh-no-install")
+
+				// Create a single server config from CLI flags
+				cfg.Web.Servers = []config.SSHServerConfig{
+					{
+						Name:        "CLI Remote Server",
+						ID:          "cli-remote",
+						RemoteHost:  sshHost,
+						RemotePort:  sshPort,
+						RemoteUser:  sshUser,
+						CommandPath: sshCommand,
+						AutoInstall: func() *bool { b := !noInstall; return &b }(),
+						Description: "Remote server configured via CLI flags",
+					},
+				}
+			}
+
 			return StartWebChatSession(cfg, V)
 		}
 
@@ -345,4 +373,10 @@ func init() {
 	rootCmd.AddCommand(chatCmd)
 	chatCmd.Flags().Bool("web", false, "Start web terminal interface")
 	chatCmd.Flags().Int("port", 0, "Web server port (default: 3000)")
+	chatCmd.Flags().String("host", "", "Web server host (default: localhost)")
+	chatCmd.Flags().String("ssh-host", "", "Remote SSH server hostname")
+	chatCmd.Flags().String("ssh-user", "", "Remote SSH username")
+	chatCmd.Flags().Int("ssh-port", 22, "Remote SSH port")
+	chatCmd.Flags().Bool("ssh-no-install", false, "Disable auto-installation of infer on remote")
+	chatCmd.Flags().String("ssh-command", "infer", "Path to infer binary on remote")
 }

Taskfile.yml

@@ -84,6 +84,13 @@ func initConfig() { // nolint:funlen
 	v.SetDefault("web.port", defaults.Web.Port)
 	v.SetDefault("web.host", defaults.Web.Host)
 	v.SetDefault("web.session_inactivity_mins", defaults.Web.SessionInactivityMins)
+	v.SetDefault("web.ssh", defaults.Web.SSH)
+	v.SetDefault("web.ssh.enabled", defaults.Web.SSH.Enabled)
+	v.SetDefault("web.ssh.use_ssh_config", defaults.Web.SSH.UseSSHConfig)
+	v.SetDefault("web.ssh.known_hosts_path", defaults.Web.SSH.KnownHostsPath)
+	v.SetDefault("web.ssh.auto_install", defaults.Web.SSH.AutoInstall)
+	v.SetDefault("web.ssh.install_version", defaults.Web.SSH.InstallVersion)
+	v.SetDefault("web.servers", defaults.Web.Servers)
 	v.SetDefault("git", defaults.Git)
 	v.SetDefault("storage", defaults.Storage)
 	v.SetDefault("conversation", defaults.Conversation)