Allow for SSE transport to expose port

Signed-off-by: Juan Antonio Osorio <[email protected]>

Author: JAORMX

cmd/vibetool/run.go

@@ -167,6 +167,23 @@ func runCmdFunc(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	// Create container options
+	containerOptions := container.NewCreateContainerOptions()
+	
+	// Set options based on transport type
+	if transportType == transport.TransportTypeSSE {
+		// For SSE transport, expose the container port
+		containerPortStr := fmt.Sprintf("%d/tcp", port)
+		containerOptions.ExposedPorts[containerPortStr] = struct{}{}
+		fmt.Printf("Exposing container port %d\n", port)
+		
+		// For SSE transport, we don't need to attach stdio
+		containerOptions.AttachStdio = false
+	} else if transportType == transport.TransportTypeStdio {
+		// For STDIO transport, we need to attach stdio
+		containerOptions.AttachStdio = true
+	}
+	
 	// Create the container
 	fmt.Printf("Creating container %s from image %s...\n", containerName, image)
 	containerID, err := runtime.CreateContainer(
@@ -177,6 +194,7 @@ func runCmdFunc(cmd *cobra.Command, args []string) error {
 		envVars,
 		containerLabels,
 		containerPermConfig,
+		containerOptions,
 	)
 	if err != nil {
 		return fmt.Errorf("failed to create container: %v", err)

pkg/container/client.go

@@ -16,6 +16,7 @@ import (
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
+	"github.com/docker/go-connections/nat"
 )
 
 // Common socket paths
@@ -125,12 +126,14 @@ func findContainerSocket() (string, RuntimeType, error) {
 }
 
 // CreateContainer creates a container without starting it
+// If options is nil, default options will be used
 func (c *Client) CreateContainer(
 	ctx context.Context,
 	image, name string,
 	command []string,
 	envVars, labels map[string]string,
 	permissionConfig PermissionConfig,
+	options *CreateContainerOptions,
 ) (string, error) {
 	// Convert environment variables to slice
 	env := make([]string, 0, len(envVars))
@@ -149,19 +152,35 @@ func (c *Client) CreateContainer(
 		})
 	}
 
+	// Determine if we should attach stdio
+	// Default to true if options is nil, otherwise use options.AttachStdio
+	attachStdio := options == nil || options.AttachStdio
+
 	// Create container configuration
 	config := &container.Config{
 		Image:        image,
 		Cmd:          command,
 		Env:          env,
 		Labels:       labels,
-		AttachStdin:  true,
-		AttachStdout: true,
-		AttachStderr: true,
-		OpenStdin:    true,
+		AttachStdin:  attachStdio,
+		AttachStdout: attachStdio,
+		AttachStderr: attachStdio,
+		OpenStdin:    attachStdio,
 		Tty:          false,
 	}
 
+	// Add exposed ports if provided
+	if options != nil && len(options.ExposedPorts) > 0 {
+		config.ExposedPorts = nat.PortSet{}
+		for port := range options.ExposedPorts {
+			natPort, err := nat.NewPort("tcp", strings.Split(port, "/")[0])
+			if err != nil {
+				return "", NewContainerError(err, "", fmt.Sprintf("failed to parse port: %v", err))
+			}
+			config.ExposedPorts[natPort] = struct{}{}
+		}
+	}
+
 	// Create host configuration
 	hostConfig := &container.HostConfig{
 		Mounts:      mounts,
@@ -171,6 +190,26 @@ func (c *Client) CreateContainer(
 		SecurityOpt: permissionConfig.SecurityOpt,
 	}
 
+	// Add port bindings if provided
+	if options != nil && len(options.PortBindings) > 0 {
+		hostConfig.PortBindings = nat.PortMap{}
+		for port, bindings := range options.PortBindings {
+			natPort, err := nat.NewPort("tcp", strings.Split(port, "/")[0])
+			if err != nil {
+				return "", NewContainerError(err, "", fmt.Sprintf("failed to parse port: %v", err))
+			}
+			
+			natBindings := make([]nat.PortBinding, len(bindings))
+			for i, binding := range bindings {
+				natBindings[i] = nat.PortBinding{
+					HostIP:   binding.HostIP,
+					HostPort: binding.HostPort,
+				}
+			}
+			hostConfig.PortBindings[natPort] = natBindings
+		}
+	}
+
 	// Create network configuration
 	networkConfig := &network.NetworkingConfig{}
 

pkg/container/types.go

@@ -39,7 +39,8 @@ type PortMapping struct {
 // Runtime defines the interface for container runtimes
 type Runtime interface {
 	// CreateContainer creates a container without starting it
-	CreateContainer(ctx context.Context, image, name string, command []string, envVars, labels map[string]string, permissionConfig PermissionConfig) (string, error)
+	// If options is nil, default options will be used
+	CreateContainer(ctx context.Context, image, name string, command []string, envVars, labels map[string]string, permissionConfig PermissionConfig, options *CreateContainerOptions) (string, error)
 
 	// StartContainer starts a container
 	StartContainer(ctx context.Context, containerID string) error
@@ -93,6 +94,40 @@ type PermissionConfig struct {
 	SecurityOpt []string
 }
 
+// CreateContainerOptions represents options for creating a container
+type CreateContainerOptions struct {
+	// ExposedPorts is a map of container ports to expose
+	// The key is in the format "port/protocol" (e.g., "8080/tcp")
+	// The value is an empty struct (not used)
+	ExposedPorts map[string]struct{}
+	
+	// PortBindings is a map of container ports to host ports
+	// The key is in the format "port/protocol" (e.g., "8080/tcp")
+	// The value is a slice of host port bindings
+	PortBindings map[string][]PortBinding
+	
+	// AttachStdio indicates whether to attach stdin/stdout/stderr
+	// This is typically set to true for stdio transport
+	AttachStdio bool
+}
+
+// PortBinding represents a host port binding
+type PortBinding struct {
+	// HostIP is the host IP to bind to (empty for all interfaces)
+	HostIP string
+	// HostPort is the host port to bind to (empty for random port)
+	HostPort string
+}
+
+// NewCreateContainerOptions creates a new CreateContainerOptions with default values
+func NewCreateContainerOptions() *CreateContainerOptions {
+	return &CreateContainerOptions{
+		ExposedPorts: make(map[string]struct{}),
+		PortBindings: make(map[string][]PortBinding),
+		AttachStdio: false,
+	}
+}
+
 // Mount represents a volume mount
 type Mount struct {
 	// Source is the source path on the host