97 lines
3.0 KiB
Go
97 lines
3.0 KiB
Go
// Command server runs the workspace microservice: a gRPC server
|
|
// exposing api/proto/workspace/v1 over the ENKLY_WORKSPACE directory on
|
|
// its own volume. Replaces internal/llm/tools.go + sandbox.go (as
|
|
// agent tool executors) and internal/handlers/files.go (as the human
|
|
// upload/download/tree backend).
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/health"
|
|
healthpb "google.golang.org/grpc/health/grpc_health_v1"
|
|
"google.golang.org/grpc/reflection"
|
|
|
|
workspacev1 "enkly/gen/workspace/v1"
|
|
"enkly/pkg/envkit"
|
|
"enkly/services/workspace/internal/infrastructure/sandboxfs"
|
|
grpcsrv "enkly/services/workspace/internal/interfaces/grpc"
|
|
)
|
|
|
|
func main() {
|
|
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
|
|
|
|
if err := envkit.LoadDotEnv(".env"); err != nil {
|
|
logger.Error("load .env", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
var (
|
|
grpcAddr = envkit.String("ENKLY_WORKSPACE_GRPC_ADDR", ":9004")
|
|
workspaceRoot = envkit.String("ENKLY_WORKSPACE", "./workspace")
|
|
bashTimeoutSeconds = envkit.Int("ENKLY_BASH_TIMEOUT_SECONDS", 0)
|
|
bashAllowlistRaw = envkit.String("ENKLY_BASH_ALLOWLIST", "")
|
|
)
|
|
|
|
toolbox, err := sandboxfs.NewToolbox(workspaceRoot)
|
|
if err != nil {
|
|
logger.Error("init toolbox", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
if bashTimeoutSeconds > 0 {
|
|
toolbox.CommandTimeout = time.Duration(bashTimeoutSeconds) * time.Second
|
|
}
|
|
// ENKLY_BASH_ALLOWLIST: comma-separated base binaries (first token
|
|
// only) run_bash_command may execute. Subcommand rules for go/git
|
|
// live in code (sandbox.go), not in this list — unchanged from the
|
|
// monolith.
|
|
if strings.TrimSpace(bashAllowlistRaw) != "" {
|
|
list, err := sandboxfs.ParseAllowlist(bashAllowlistRaw)
|
|
if err != nil {
|
|
logger.Error("invalid ENKLY_BASH_ALLOWLIST", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
toolbox.AllowedCommands = list
|
|
}
|
|
logger.Info("workspace ready", "root", toolbox.WorkspaceRoot, "bash_timeout", toolbox.CommandTimeout)
|
|
|
|
lis, err := net.Listen("tcp", grpcAddr)
|
|
if err != nil {
|
|
logger.Error("listen", "addr", grpcAddr, "err", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// MaxRecvMsgSize/MaxSendMsgSize raised above gRPC's 4 MiB default:
|
|
// UploadFile/DownloadFile/WriteFile can legitimately carry a
|
|
// multi-megabyte file (see maxUploadFileBytes in the gateway's
|
|
// files handler, which is also 20 MiB).
|
|
grpcServer := grpc.NewServer(grpc.MaxRecvMsgSize(24<<20), grpc.MaxSendMsgSize(24<<20))
|
|
workspacev1.RegisterWorkspaceServiceServer(grpcServer, grpcsrv.New(toolbox))
|
|
healthSrv := health.NewServer()
|
|
healthpb.RegisterHealthServer(grpcServer, healthSrv)
|
|
healthSrv.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
|
|
reflection.Register(grpcServer)
|
|
|
|
go func() {
|
|
logger.Info("workspace service listening", "addr", grpcAddr)
|
|
if err := grpcServer.Serve(lis); err != nil {
|
|
logger.Error("serve", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
}()
|
|
|
|
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
|
defer stop()
|
|
<-ctx.Done()
|
|
logger.Info("shutting down")
|
|
grpcServer.GracefulStop()
|
|
}
|