Add files using upload-large-folder tool

aiml/02_models/elizabeth/deployment_configs/.env.cloudflare.example

@@ -0,0 +1,18 @@
+# Cloudflare API Configuration
+# Copy this file to .env.cloudflare and fill in your credentials
+
+CLOUDFLARE_API_TOKEN=your_cloudflare_api_token_here
+CLOUDFLARE_ZONE_ID=your_cloudflare_zone_id_here
+CLOUDFLARE_ACCOUNT_ID=your_cloudflare_account_id_here
+
+# Server Configuration (update with actual server IP)
+SERVER_PUBLIC_IP=your_server_public_ip_here
+SERVER_PORT=8000
+
+# Domain Configuration
+PRIMARY_DOMAIN=adaptdev.ai
+CUSTOM_DOMAIN=corpus.adaptdev.ai
+CDN_BASE=https://cdn.adaptdev.ai
+
+# API Configuration
+API_BASE_URL=https://api.cloudflare.com/client/v4

aiml/02_models/elizabeth/legacy_workspace/.env

@@ -0,0 +1,42 @@
+# Elizabeth Environment Variables
+ELIZABETH_VERSION=v0.0.2
+VLLM_BASE_URL=http://localhost:8
+MODEL_PATH=/workspace/models/qwen3-8b
+
+# Database Connections
+PG_HOST=localhost
+PG_DATABASE=elizabeth_prod
+PG_USER=elizabeth
+PG_PASSWORD=
+
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+MONGO_URI=mongodb://localhost:27017/
+
+# HuggingFace API Configuration - #FRESH - 250705
+HUGGING_FACE_API_KEY=
+HF_TOKEN=
+HF_ORG=LevelUp2x
+
+# Xet Configuration
+XET_REPO_URL=https://xetbeta.com/adaptnova/elizabeth-data
+XET_LOCAL_PATH=/workspace/xet_data
+
+# Search API Keys - Configure for enhanced web search
+FIRECRAWL_API_KEY=fc-94ebc24ae6a4492f9022d6a83001fc54
+TAVILY_API_KEY=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
+SERPER_API_KEY=aace3627d2b7d008f85ce06100984ae7c2a2066f
+
+# Search Configuration
+SEARCH_PROVIDER=firecrawl  # firecrawl, tavily, serper, duckduckgo, perplexity
+SEARCH_MAX_RESULTS=5
+SEARCH_TIMEOUT=30
+
+# Additional Search Services
+PERPLEXITY_API_KEY=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
+
+# Algolia Search Configuration
+ALGOLIA_APPLICATION_ID=H23FYV09PA
+ALGOLIA_SEARCH_API_KEY=7d71ebe7bf1f76a6bb14aecfae798372
+ALGOLIA_WRITE_API_KEY=4d8787832cc1a7920f68df7e791e75bb

aiml/04_data/etl_pipelines/legacy_etl/corpus-pipeline/.env

@@ -0,0 +1,34 @@
+# Nebius COS S3 Configuration
+AWS_ACCESS_KEY_ID=NAKIK7HQMWO2I8Y315Y6
+AWS_SECRET_ACCESS_KEY=O7+KZpqwNfAMHV3cz6anSaFz3f8ppI1M1cfEeYU5
+AWS_ENDPOINT_URL=https://storage.us-central1.nebius.cloud:443
+AWS_DEFAULT_REGION=us-central1
+S3_BUCKET=cos
+
+# Nebius API Configuration
+NEBIUS_TENANT_ID=tenant-e00x2jmwjyzm485zsy
+NEBIUS_SERVICE_ACCOUNT_ID=serviceaccount-e00q63c932nw0qp6s0
+NEBIUS_API_KEY_ID=NAKIK7HQMWO2I8Y315Y6
+
+# Google Cloud Storage
+GCS_BUCKET=gs://gc-cos
+
+# NFS Mount Points
+NFS_INTERNAL=10.128.0.3:/lssd
+NFS_EXTERNAL=35.223.4.118:/lssd
+LOCAL_MOUNT=/mnt/corpus-storage
+
+# Pipeline Configuration
+CORPUS_DIR=/data/adaptai/corpus-data
+RAW_DIR=/data/adaptai/corpus-data/raw
+PROCESSED_DIR=/data/adaptai/corpus-data/processed
+TRAINING_DIR=/data/adaptai/corpus-data/training
+LOG_DIR=/data/adaptai/corpus-data/logs
+
+# PostgreSQL Configuration
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_DB=nova_conversations
+POSTGRES_USER=mlops_etl_user
+POSTGRES_PASSWORD=quantum_secure_20250824_vox_atlas_archimedes
+POSTGRES_SCHEMA=conversation_corpus

projects/ui/crush/internal/session/session.go

@@ -0,0 +1,156 @@
+package session
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/pubsub"
+	"github.com/google/uuid"
+)
+
+type Session struct {
+	ID               string
+	ParentSessionID  string
+	Title            string
+	MessageCount     int64
+	PromptTokens     int64
+	CompletionTokens int64
+	SummaryMessageID string
+	Cost             float64
+	CreatedAt        int64
+	UpdatedAt        int64
+}
+
+type Service interface {
+	pubsub.Suscriber[Session]
+	Create(ctx context.Context, title string) (Session, error)
+	CreateTitleSession(ctx context.Context, parentSessionID string) (Session, error)
+	CreateTaskSession(ctx context.Context, toolCallID, parentSessionID, title string) (Session, error)
+	Get(ctx context.Context, id string) (Session, error)
+	List(ctx context.Context) ([]Session, error)
+	Save(ctx context.Context, session Session) (Session, error)
+	Delete(ctx context.Context, id string) error
+}
+
+type service struct {
+	*pubsub.Broker[Session]
+	q db.Querier
+}
+
+func (s *service) Create(ctx context.Context, title string) (Session, error) {
+	dbSession, err := s.q.CreateSession(ctx, db.CreateSessionParams{
+		ID:    uuid.New().String(),
+		Title: title,
+	})
+	if err != nil {
+		return Session{}, err
+	}
+	session := s.fromDBItem(dbSession)
+	s.Publish(pubsub.CreatedEvent, session)
+	return session, nil
+}
+
+func (s *service) CreateTaskSession(ctx context.Context, toolCallID, parentSessionID, title string) (Session, error) {
+	dbSession, err := s.q.CreateSession(ctx, db.CreateSessionParams{
+		ID:              toolCallID,
+		ParentSessionID: sql.NullString{String: parentSessionID, Valid: true},
+		Title:           title,
+	})
+	if err != nil {
+		return Session{}, err
+	}
+	session := s.fromDBItem(dbSession)
+	s.Publish(pubsub.CreatedEvent, session)
+	return session, nil
+}
+
+func (s *service) CreateTitleSession(ctx context.Context, parentSessionID string) (Session, error) {
+	dbSession, err := s.q.CreateSession(ctx, db.CreateSessionParams{
+		ID:              "title-" + parentSessionID,
+		ParentSessionID: sql.NullString{String: parentSessionID, Valid: true},
+		Title:           "Generate a title",
+	})
+	if err != nil {
+		return Session{}, err
+	}
+	session := s.fromDBItem(dbSession)
+	s.Publish(pubsub.CreatedEvent, session)
+	return session, nil
+}
+
+func (s *service) Delete(ctx context.Context, id string) error {
+	session, err := s.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+	err = s.q.DeleteSession(ctx, session.ID)
+	if err != nil {
+		return err
+	}
+	s.Publish(pubsub.DeletedEvent, session)
+	return nil
+}
+
+func (s *service) Get(ctx context.Context, id string) (Session, error) {
+	dbSession, err := s.q.GetSessionByID(ctx, id)
+	if err != nil {
+		return Session{}, err
+	}
+	return s.fromDBItem(dbSession), nil
+}
+
+func (s *service) Save(ctx context.Context, session Session) (Session, error) {
+	dbSession, err := s.q.UpdateSession(ctx, db.UpdateSessionParams{
+		ID:               session.ID,
+		Title:            session.Title,
+		PromptTokens:     session.PromptTokens,
+		CompletionTokens: session.CompletionTokens,
+		SummaryMessageID: sql.NullString{
+			String: session.SummaryMessageID,
+			Valid:  session.SummaryMessageID != "",
+		},
+		Cost: session.Cost,
+	})
+	if err != nil {
+		return Session{}, err
+	}
+	session = s.fromDBItem(dbSession)
+	s.Publish(pubsub.UpdatedEvent, session)
+	return session, nil
+}
+
+func (s *service) List(ctx context.Context) ([]Session, error) {
+	dbSessions, err := s.q.ListSessions(ctx)
+	if err != nil {
+		return nil, err
+	}
+	sessions := make([]Session, len(dbSessions))
+	for i, dbSession := range dbSessions {
+		sessions[i] = s.fromDBItem(dbSession)
+	}
+	return sessions, nil
+}
+
+func (s service) fromDBItem(item db.Session) Session {
+	return Session{
+		ID:               item.ID,
+		ParentSessionID:  item.ParentSessionID.String,
+		Title:            item.Title,
+		MessageCount:     item.MessageCount,
+		PromptTokens:     item.PromptTokens,
+		CompletionTokens: item.CompletionTokens,
+		SummaryMessageID: item.SummaryMessageID.String,
+		Cost:             item.Cost,
+		CreatedAt:        item.CreatedAt,
+		UpdatedAt:        item.UpdatedAt,
+	}
+}
+
+func NewService(q db.Querier) Service {
+	broker := pubsub.NewBroker[Session]()
+	return &service{
+		broker,
+		q,
+	}
+}

projects/ui/crush/internal/shell/command_block_test.go

@@ -0,0 +1,377 @@
+package shell
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCommandBlocking(t *testing.T) {
+	tests := []struct {
+		name        string
+		blockFuncs  []BlockFunc
+		command     string
+		shouldBlock bool
+	}{
+		{
+			name: "block simple command",
+			blockFuncs: []BlockFunc{
+				func(args []string) bool {
+					return len(args) > 0 && args[0] == "curl"
+				},
+			},
+			command:     "curl https://example.com",
+			shouldBlock: true,
+		},
+		{
+			name: "allow non-blocked command",
+			blockFuncs: []BlockFunc{
+				func(args []string) bool {
+					return len(args) > 0 && args[0] == "curl"
+				},
+			},
+			command:     "echo hello",
+			shouldBlock: false,
+		},
+		{
+			name: "block subcommand",
+			blockFuncs: []BlockFunc{
+				func(args []string) bool {
+					return len(args) >= 2 && args[0] == "brew" && args[1] == "install"
+				},
+			},
+			command:     "brew install wget",
+			shouldBlock: true,
+		},
+		{
+			name: "allow different subcommand",
+			blockFuncs: []BlockFunc{
+				func(args []string) bool {
+					return len(args) >= 2 && args[0] == "brew" && args[1] == "install"
+				},
+			},
+			command:     "brew list",
+			shouldBlock: false,
+		},
+		{
+			name: "block npm global install with -g",
+			blockFuncs: []BlockFunc{
+				ArgumentsBlocker("npm", []string{"install"}, []string{"-g"}),
+			},
+			command:     "npm install -g typescript",
+			shouldBlock: true,
+		},
+		{
+			name: "block npm global install with --global",
+			blockFuncs: []BlockFunc{
+				ArgumentsBlocker("npm", []string{"install"}, []string{"--global"}),
+			},
+			command:     "npm install --global typescript",
+			shouldBlock: true,
+		},
+		{
+			name: "allow npm local install",
+			blockFuncs: []BlockFunc{
+				ArgumentsBlocker("npm", []string{"install"}, []string{"-g"}),
+				ArgumentsBlocker("npm", []string{"install"}, []string{"--global"}),
+			},
+			command:     "npm install typescript",
+			shouldBlock: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary directory for each test
+			tmpDir := t.TempDir()
+
+			shell := NewShell(&Options{
+				WorkingDir: tmpDir,
+				BlockFuncs: tt.blockFuncs,
+			})
+
+			_, _, err := shell.Exec(context.Background(), tt.command)
+
+			if tt.shouldBlock {
+				if err == nil {
+					t.Errorf("Expected command to be blocked, but it was allowed")
+				} else if !strings.Contains(err.Error(), "not allowed for security reasons") {
+					t.Errorf("Expected security error, got: %v", err)
+				}
+			} else {
+				// For non-blocked commands, we might get other errors (like command not found)
+				// but we shouldn't get the security error
+				if err != nil && strings.Contains(err.Error(), "not allowed for security reasons") {
+					t.Errorf("Command was unexpectedly blocked: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestArgumentsBlocker(t *testing.T) {
+	tests := []struct {
+		name        string
+		cmd         string
+		args        []string
+		flags       []string
+		input       []string
+		shouldBlock bool
+	}{
+		// Basic command blocking
+		{
+			name:        "block exact command match",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       nil,
+			input:       []string{"npm", "install", "package"},
+			shouldBlock: true,
+		},
+		{
+			name:        "allow different command",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       nil,
+			input:       []string{"yarn", "install", "package"},
+			shouldBlock: false,
+		},
+		{
+			name:        "allow different subcommand",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       nil,
+			input:       []string{"npm", "list"},
+			shouldBlock: false,
+		},
+
+		// Flag-based blocking
+		{
+			name:        "block with single flag",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       []string{"-g"},
+			input:       []string{"npm", "install", "-g", "typescript"},
+			shouldBlock: true,
+		},
+		{
+			name:        "block with flag in different position",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       []string{"-g"},
+			input:       []string{"npm", "install", "typescript", "-g"},
+			shouldBlock: true,
+		},
+		{
+			name:        "allow without required flag",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       []string{"-g"},
+			input:       []string{"npm", "install", "typescript"},
+			shouldBlock: false,
+		},
+		{
+			name:        "block with multiple flags",
+			cmd:         "pip",
+			args:        []string{"install"},
+			flags:       []string{"--user"},
+			input:       []string{"pip", "install", "--user", "--upgrade", "package"},
+			shouldBlock: true,
+		},
+
+		// Complex argument patterns
+		{
+			name:        "block multi-arg subcommand",
+			cmd:         "yarn",
+			args:        []string{"global", "add"},
+			flags:       nil,
+			input:       []string{"yarn", "global", "add", "typescript"},
+			shouldBlock: true,
+		},
+		{
+			name:        "allow partial multi-arg match",
+			cmd:         "yarn",
+			args:        []string{"global", "add"},
+			flags:       nil,
+			input:       []string{"yarn", "global", "list"},
+			shouldBlock: false,
+		},
+
+		// Edge cases
+		{
+			name:        "handle empty input",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       nil,
+			input:       []string{},
+			shouldBlock: false,
+		},
+		{
+			name:        "handle command only",
+			cmd:         "npm",
+			args:        []string{"install"},
+			flags:       nil,
+			input:       []string{"npm"},
+			shouldBlock: false,
+		},
+		{
+			name:        "block pacman with -S flag",
+			cmd:         "pacman",
+			args:        nil,
+			flags:       []string{"-S"},
+			input:       []string{"pacman", "-S", "package"},
+			shouldBlock: true,
+		},
+		{
+			name:        "allow pacman without -S flag",
+			cmd:         "pacman",
+			args:        nil,
+			flags:       []string{"-S"},
+			input:       []string{"pacman", "-Q", "package"},
+			shouldBlock: false,
+		},
+
+		// `go test -exec`
+		{
+			name:        "go test exec",
+			cmd:         "go",
+			args:        []string{"test"},
+			flags:       []string{"-exec"},
+			input:       []string{"go", "test", "-exec", "bash -c 'echo hello'"},
+			shouldBlock: true,
+		},
+		{
+			name:        "go test exec",
+			cmd:         "go",
+			args:        []string{"test"},
+			flags:       []string{"-exec"},
+			input:       []string{"go", "test", `-exec="bash -c 'echo hello'"`},
+			shouldBlock: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			blocker := ArgumentsBlocker(tt.cmd, tt.args, tt.flags)
+			result := blocker(tt.input)
+			require.Equal(t, tt.shouldBlock, result,
+				"Expected block=%v for input %v", tt.shouldBlock, tt.input)
+		})
+	}
+}
+
+func TestCommandsBlocker(t *testing.T) {
+	tests := []struct {
+		name        string
+		banned      []string
+		input       []string
+		shouldBlock bool
+	}{
+		{
+			name:        "block single banned command",
+			banned:      []string{"curl"},
+			input:       []string{"curl", "https://example.com"},
+			shouldBlock: true,
+		},
+		{
+			name:        "allow non-banned command",
+			banned:      []string{"curl", "wget"},
+			input:       []string{"echo", "hello"},
+			shouldBlock: false,
+		},
+		{
+			name:        "block from multiple banned",
+			banned:      []string{"curl", "wget", "nc"},
+			input:       []string{"wget", "https://example.com"},
+			shouldBlock: true,
+		},
+		{
+			name:        "handle empty input",
+			banned:      []string{"curl"},
+			input:       []string{},
+			shouldBlock: false,
+		},
+		{
+			name:        "case sensitive matching",
+			banned:      []string{"curl"},
+			input:       []string{"CURL", "https://example.com"},
+			shouldBlock: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			blocker := CommandsBlocker(tt.banned)
+			result := blocker(tt.input)
+			require.Equal(t, tt.shouldBlock, result,
+				"Expected block=%v for input %v", tt.shouldBlock, tt.input)
+		})
+	}
+}
+
+func TestSplitArgsFlags(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     []string
+		wantArgs  []string
+		wantFlags []string
+	}{
+		{
+			name:      "only args",
+			input:     []string{"install", "package", "another"},
+			wantArgs:  []string{"install", "package", "another"},
+			wantFlags: []string{},
+		},
+		{
+			name:      "only flags",
+			input:     []string{"-g", "--verbose", "-f"},
+			wantArgs:  []string{},
+			wantFlags: []string{"-g", "--verbose", "-f"},
+		},
+		{
+			name:      "mixed args and flags",
+			input:     []string{"install", "-g", "package", "--verbose"},
+			wantArgs:  []string{"install", "package"},
+			wantFlags: []string{"-g", "--verbose"},
+		},
+		{
+			name:      "empty input",
+			input:     []string{},
+			wantArgs:  []string{},
+			wantFlags: []string{},
+		},
+		{
+			name:      "single dash flag",
+			input:     []string{"-S", "package"},
+			wantArgs:  []string{"package"},
+			wantFlags: []string{"-S"},
+		},
+		{
+			name:      "flag with equals sign",
+			input:     []string{"-exec=bash", "package"},
+			wantArgs:  []string{"package"},
+			wantFlags: []string{"-exec"},
+		},
+		{
+			name:      "long flag with equals sign",
+			input:     []string{"--config=/path/to/config", "run"},
+			wantArgs:  []string{"run"},
+			wantFlags: []string{"--config"},
+		},
+		{
+			name:      "flag with complex value",
+			input:     []string{`-exec="bash -c 'echo hello'"`, "test"},
+			wantArgs:  []string{"test"},
+			wantFlags: []string{"-exec"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			args, flags := splitArgsFlags(tt.input)
+			require.Equal(t, tt.wantArgs, args, "args mismatch")
+			require.Equal(t, tt.wantFlags, flags, "flags mismatch")
+		})
+	}
+}

projects/ui/crush/internal/shell/comparison_test.go

@@ -0,0 +1,41 @@
+package shell
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestShellPerformanceComparison(t *testing.T) {
+	shell := NewShell(&Options{WorkingDir: t.TempDir()})
+
+	// Test quick command
+	start := time.Now()
+	stdout, stderr, err := shell.Exec(t.Context(), "echo 'hello'")
+	exitCode := ExitCode(err)
+	duration := time.Since(start)
+
+	require.NoError(t, err)
+	require.Equal(t, 0, exitCode)
+	require.Contains(t, stdout, "hello")
+	require.Empty(t, stderr)
+
+	t.Logf("Quick command took: %v", duration)
+}
+
+// Benchmark CPU usage during polling
+func BenchmarkShellPolling(b *testing.B) {
+	shell := NewShell(&Options{WorkingDir: b.TempDir()})
+
+	b.ReportAllocs()
+
+	for b.Loop() {
+		// Use a short sleep to measure polling overhead
+		_, _, err := shell.Exec(b.Context(), "sleep 0.02")
+		exitCode := ExitCode(err)
+		if err != nil || exitCode != 0 {
+			b.Fatalf("Command failed: %v, exit code: %d", err, exitCode)
+		}
+	}
+}

projects/ui/crush/internal/shell/doc.go

@@ -0,0 +1,30 @@
+package shell
+
+// Example usage of the shell package:
+//
+// 1. For one-off commands:
+//
+//	shell := shell.NewShell(nil)
+//	stdout, stderr, err := shell.Exec(context.Background(), "echo hello")
+//
+// 2. For maintaining state across commands:
+//
+//	shell := shell.NewShell(&shell.Options{
+//	    WorkingDir: "/tmp",
+//	    Logger: myLogger,
+//	})
+//	shell.Exec(ctx, "export FOO=bar")
+//	shell.Exec(ctx, "echo $FOO")  // Will print "bar"
+//
+// 3. For the singleton persistent shell (used by tools):
+//
+//	shell := shell.GetPersistentShell("/path/to/cwd")
+//	stdout, stderr, err := shell.Exec(ctx, "ls -la")
+//
+// 4. Managing environment and working directory:
+//
+//	shell := shell.NewShell(nil)
+//	shell.SetEnv("MY_VAR", "value")
+//	shell.SetWorkingDir("/tmp")
+//	cwd := shell.GetWorkingDir()
+//	env := shell.GetEnv()

projects/ui/crush/internal/shell/persistent.go

@@ -0,0 +1,37 @@
+package shell
+
+import (
+	"log/slog"
+	"sync"
+)
+
+// PersistentShell is a singleton shell instance that maintains state across the application
+type PersistentShell struct {
+	*Shell
+}
+
+var (
+	once          sync.Once
+	shellInstance *PersistentShell
+)
+
+// GetPersistentShell returns the singleton persistent shell instance
+// This maintains backward compatibility with the existing API
+func GetPersistentShell(cwd string) *PersistentShell {
+	once.Do(func() {
+		shellInstance = &PersistentShell{
+			Shell: NewShell(&Options{
+				WorkingDir: cwd,
+				Logger:     &loggingAdapter{},
+			}),
+		}
+	})
+	return shellInstance
+}
+
+// slog.dapter adapts the internal slog.package to the Logger interface
+type loggingAdapter struct{}
+
+func (l *loggingAdapter) InfoPersist(msg string, keysAndValues ...any) {
+	slog.Info(msg, keysAndValues...)
+}

projects/ui/crush/internal/shell/shell.go

@@ -0,0 +1,276 @@
+// Package shell provides cross-platform shell execution capabilities.
+//
+// This package offers two main types:
+// - Shell: A general-purpose shell executor for one-off or managed commands
+// - PersistentShell: A singleton shell that maintains state across the application
+//
+// WINDOWS COMPATIBILITY:
+// This implementation provides both POSIX shell emulation (mvdan.cc/sh/v3),
+// even on Windows. Some caution has to be taken: commands should have forward
+// slashes (/) as path separators to work, even on Windows.
+package shell
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/charmbracelet/x/exp/slice"
+	"mvdan.cc/sh/moreinterp/coreutils"
+	"mvdan.cc/sh/v3/expand"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
+)
+
+// ShellType represents the type of shell to use
+type ShellType int
+
+const (
+	ShellTypePOSIX ShellType = iota
+	ShellTypeCmd
+	ShellTypePowerShell
+)
+
+// Logger interface for optional logging
+type Logger interface {
+	InfoPersist(msg string, keysAndValues ...any)
+}
+
+// noopLogger is a logger that does nothing
+type noopLogger struct{}
+
+func (noopLogger) InfoPersist(msg string, keysAndValues ...any) {}
+
+// BlockFunc is a function that determines if a command should be blocked
+type BlockFunc func(args []string) bool
+
+// Shell provides cross-platform shell execution with optional state persistence
+type Shell struct {
+	env        []string
+	cwd        string
+	mu         sync.Mutex
+	logger     Logger
+	blockFuncs []BlockFunc
+}
+
+// Options for creating a new shell
+type Options struct {
+	WorkingDir string
+	Env        []string
+	Logger     Logger
+	BlockFuncs []BlockFunc
+}
+
+// NewShell creates a new shell instance with the given options
+func NewShell(opts *Options) *Shell {
+	if opts == nil {
+		opts = &Options{}
+	}
+
+	cwd := opts.WorkingDir
+	if cwd == "" {
+		cwd, _ = os.Getwd()
+	}
+
+	env := opts.Env
+	if env == nil {
+		env = os.Environ()
+	}
+
+	logger := opts.Logger
+	if logger == nil {
+		logger = noopLogger{}
+	}
+
+	return &Shell{
+		cwd:        cwd,
+		env:        env,
+		logger:     logger,
+		blockFuncs: opts.BlockFuncs,
+	}
+}
+
+// Exec executes a command in the shell
+func (s *Shell) Exec(ctx context.Context, command string) (string, string, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	return s.execPOSIX(ctx, command)
+}
+
+// GetWorkingDir returns the current working directory
+func (s *Shell) GetWorkingDir() string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.cwd
+}
+
+// SetWorkingDir sets the working directory
+func (s *Shell) SetWorkingDir(dir string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Verify the directory exists
+	if _, err := os.Stat(dir); err != nil {
+		return fmt.Errorf("directory does not exist: %w", err)
+	}
+
+	s.cwd = dir
+	return nil
+}
+
+// GetEnv returns a copy of the environment variables
+func (s *Shell) GetEnv() []string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	env := make([]string, len(s.env))
+	copy(env, s.env)
+	return env
+}
+
+// SetEnv sets an environment variable
+func (s *Shell) SetEnv(key, value string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Update or add the environment variable
+	keyPrefix := key + "="
+	for i, env := range s.env {
+		if strings.HasPrefix(env, keyPrefix) {
+			s.env[i] = keyPrefix + value
+			return
+		}
+	}
+	s.env = append(s.env, keyPrefix+value)
+}
+
+// SetBlockFuncs sets the command block functions for the shell
+func (s *Shell) SetBlockFuncs(blockFuncs []BlockFunc) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.blockFuncs = blockFuncs
+}
+
+// CommandsBlocker creates a BlockFunc that blocks exact command matches
+func CommandsBlocker(cmds []string) BlockFunc {
+	bannedSet := make(map[string]struct{})
+	for _, cmd := range cmds {
+		bannedSet[cmd] = struct{}{}
+	}
+
+	return func(args []string) bool {
+		if len(args) == 0 {
+			return false
+		}
+		_, ok := bannedSet[args[0]]
+		return ok
+	}
+}
+
+// ArgumentsBlocker creates a BlockFunc that blocks specific subcommand
+func ArgumentsBlocker(cmd string, args []string, flags []string) BlockFunc {
+	return func(parts []string) bool {
+		if len(parts) == 0 || parts[0] != cmd {
+			return false
+		}
+
+		argParts, flagParts := splitArgsFlags(parts[1:])
+		if len(argParts) < len(args) || len(flagParts) < len(flags) {
+			return false
+		}
+
+		argsMatch := slices.Equal(argParts[:len(args)], args)
+		flagsMatch := slice.IsSubset(flags, flagParts)
+
+		return argsMatch && flagsMatch
+	}
+}
+
+func splitArgsFlags(parts []string) (args []string, flags []string) {
+	args = make([]string, 0, len(parts))
+	flags = make([]string, 0, len(parts))
+	for _, part := range parts {
+		if strings.HasPrefix(part, "-") {
+			// Extract flag name before '=' if present
+			flag := part
+			if idx := strings.IndexByte(part, '='); idx != -1 {
+				flag = part[:idx]
+			}
+			flags = append(flags, flag)
+		} else {
+			args = append(args, part)
+		}
+	}
+	return
+}
+
+func (s *Shell) blockHandler() func(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
+	return func(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
+		return func(ctx context.Context, args []string) error {
+			if len(args) == 0 {
+				return next(ctx, args)
+			}
+
+			for _, blockFunc := range s.blockFuncs {
+				if blockFunc(args) {
+					return fmt.Errorf("command is not allowed for security reasons: %s", strings.Join(args, " "))
+				}
+			}
+
+			return next(ctx, args)
+		}
+	}
+}
+
+// execPOSIX executes commands using POSIX shell emulation (cross-platform)
+func (s *Shell) execPOSIX(ctx context.Context, command string) (string, string, error) {
+	line, err := syntax.NewParser().Parse(strings.NewReader(command), "")
+	if err != nil {
+		return "", "", fmt.Errorf("could not parse command: %w", err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	runner, err := interp.New(
+		interp.StdIO(nil, &stdout, &stderr),
+		interp.Interactive(false),
+		interp.Env(expand.ListEnviron(s.env...)),
+		interp.Dir(s.cwd),
+		interp.ExecHandlers(s.blockHandler(), coreutils.ExecHandler),
+	)
+	if err != nil {
+		return "", "", fmt.Errorf("could not run command: %w", err)
+	}
+
+	err = runner.Run(ctx, line)
+	s.cwd = runner.Dir
+	s.env = []string{}
+	for name, vr := range runner.Vars {
+		s.env = append(s.env, fmt.Sprintf("%s=%s", name, vr.Str))
+	}
+	s.logger.InfoPersist("POSIX command finished", "command", command, "err", err)
+	return stdout.String(), stderr.String(), err
+}
+
+// IsInterrupt checks if an error is due to interruption
+func IsInterrupt(err error) bool {
+	return errors.Is(err, context.Canceled) ||
+		errors.Is(err, context.DeadlineExceeded)
+}
+
+// ExitCode extracts the exit code from an error
+func ExitCode(err error) int {
+	if err == nil {
+		return 0
+	}
+	var exitErr interp.ExitStatus
+	if errors.As(err, &exitErr) {
+		return int(exitErr)
+	}
+	return 1
+}

projects/ui/crush/internal/shell/shell_test.go

@@ -0,0 +1,120 @@
+package shell
+
+import (
+	"context"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Benchmark to measure CPU efficiency
+func BenchmarkShellQuickCommands(b *testing.B) {
+	shell := NewShell(&Options{WorkingDir: b.TempDir()})
+
+	b.ReportAllocs()
+
+	for b.Loop() {
+		_, _, err := shell.Exec(context.Background(), "echo test")
+		exitCode := ExitCode(err)
+		if err != nil || exitCode != 0 {
+			b.Fatalf("Command failed: %v, exit code: %d", err, exitCode)
+		}
+	}
+}
+
+func TestTestTimeout(t *testing.T) {
+	// XXX(@andreynering): This fails on Windows. Address once possible.
+	if runtime.GOOS == "windows" {
+		t.Skip("Skipping test on Windows")
+	}
+
+	ctx, cancel := context.WithTimeout(t.Context(), time.Millisecond)
+	t.Cleanup(cancel)
+
+	shell := NewShell(&Options{WorkingDir: t.TempDir()})
+	_, _, err := shell.Exec(ctx, "sleep 10")
+	if status := ExitCode(err); status == 0 {
+		t.Fatalf("Expected non-zero exit status, got %d", status)
+	}
+	if !IsInterrupt(err) {
+		t.Fatalf("Expected command to be interrupted, but it was not")
+	}
+	if err == nil {
+		t.Fatalf("Expected an error due to timeout, but got none")
+	}
+}
+
+func TestTestCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(t.Context())
+	cancel() // immediately cancel the context
+
+	shell := NewShell(&Options{WorkingDir: t.TempDir()})
+	_, _, err := shell.Exec(ctx, "sleep 10")
+	if status := ExitCode(err); status == 0 {
+		t.Fatalf("Expected non-zero exit status, got %d", status)
+	}
+	if !IsInterrupt(err) {
+		t.Fatalf("Expected command to be interrupted, but it was not")
+	}
+	if err == nil {
+		t.Fatalf("Expected an error due to cancel, but got none")
+	}
+}
+
+func TestRunCommandError(t *testing.T) {
+	shell := NewShell(&Options{WorkingDir: t.TempDir()})
+	_, _, err := shell.Exec(t.Context(), "nopenopenope")
+	if status := ExitCode(err); status == 0 {
+		t.Fatalf("Expected non-zero exit status, got %d", status)
+	}
+	if IsInterrupt(err) {
+		t.Fatalf("Expected command to not be interrupted, but it was")
+	}
+	if err == nil {
+		t.Fatalf("Expected an error, got nil")
+	}
+}
+
+func TestRunContinuity(t *testing.T) {
+	tempDir1 := t.TempDir()
+	tempDir2 := t.TempDir()
+
+	shell := NewShell(&Options{WorkingDir: tempDir1})
+	if _, _, err := shell.Exec(t.Context(), "export FOO=bar"); err != nil {
+		t.Fatalf("failed to set env: %v", err)
+	}
+	if _, _, err := shell.Exec(t.Context(), "cd "+filepath.ToSlash(tempDir2)); err != nil {
+		t.Fatalf("failed to change directory: %v", err)
+	}
+	out, _, err := shell.Exec(t.Context(), "echo $FOO ; pwd")
+	if err != nil {
+		t.Fatalf("failed to echo: %v", err)
+	}
+	expect := "bar\n" + tempDir2 + "\n"
+	if out != expect {
+		t.Fatalf("expected output %q, got %q", expect, out)
+	}
+}
+
+func TestCrossPlatformExecution(t *testing.T) {
+	shell := NewShell(&Options{WorkingDir: "."})
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// Test a simple command that should work on all platforms
+	stdout, stderr, err := shell.Exec(ctx, "echo hello")
+	if err != nil {
+		t.Fatalf("Echo command failed: %v, stderr: %s", err, stderr)
+	}
+
+	if stdout == "" {
+		t.Error("Echo command produced no output")
+	}
+
+	// The output should contain "hello" regardless of platform
+	if !strings.Contains(strings.ToLower(stdout), "hello") {
+		t.Errorf("Echo output should contain 'hello', got: %q", stdout)
+	}
+}