feat(upstream): launch local HTTP/SSE upstreams via launcher (Phase 1)

Wires internal/upstream/launcher into Client.Connect for the http,
sse, and streamable-http transports when ServerConfig.Command is also
set. The launcher spawns the child process, blocks on
launcher.WaitForURL until the listener accepts a TCP connection, then
hands off to the existing transport-level connectHTTP / connectSSE.
On Disconnect, the MCP client is closed first (so the child sees the
network drop cleanly) and the launcher Handle is Stop()ed second
(SIGTERM -> grace -> SIGKILL).

Stdio is deliberately excluded: mcp-go's Stdio transport spawns its
own child via its CommandFunc, and routing that through launcher.Spawn
would require patching mcp-go. Instead, both the stdio CommandFunc
path and the new HTTP/SSE launcher path call into the same set of
*Client command-prep helpers (setupDockerIsolation, wrapWithUserShell,
injectEnvVarsIntoDockerArgs, insertCidfileIntoShellDockerCommand),
preserving the spec's "Docker isolation in one place" requirement
without the riskier stdio refactor.

Config / API:
- ServerConfig.LauncherWaitTimeout (Duration, default 30s) caps the
  wait between spawn and listener-up. CopyServerConfig carries it.
- Client gains launcherHandle / launcherCIDFile fields. Stdio Clients
  leave them nil so existing cleanup paths (killProcessGroup,
  processCmd.Process.Kill) keep their single owner.

Behaviour back-compat: when Command is set together with a URL but
no explicit protocol, Command still wins -> stdio, URL ignored
(matches today). To opt into the launcher you must set protocol to
"http", "sse", or "streamable-http" explicitly.

Locking: Connect holds c.mu for its duration, so the failure-cleanup
path inlines the launcher teardown and releases c.mu briefly around
handle.Stop (which can block until the child is reaped). The
connecting flag prevents a concurrent Connect from sneaking in
during that window. DisconnectWithContext releases c.mu before its
stopLauncher call, so the public method uses normal locking.

Watch goroutine: on unexpected child exit while connected,
watchLauncher invokes Disconnect so the existing reconnect loop in
internal/upstream/manager takes over instead of waiting for the
transport's keepalive to time out.

Verified by go vet + the full internal/upstream/... and
internal/config/... test suites (existing tests stay green; deadlock
in connect-failure cleanup that surfaced in TestClient_Connect_SSE_
NotSupported was fixed before commit).

Refs spec: specs/046-local-launcher-for-http-sse/plan.md

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: electrolobzik

internal/config/config.go

@@ -224,6 +224,13 @@ type ServerConfig struct {
 	Updated        time.Time         `json:"updated,omitempty" mapstructure:"updated"`
 	Isolation      *IsolationConfig  `json:"isolation,omitempty" mapstructure:"isolation"`               // Per-server isolation settings
 	ReconnectOnUse bool              `json:"reconnect_on_use,omitempty" mapstructure:"reconnect-on-use"` // Attempt reconnection when a tool call targets a disconnected server
+
+	// LauncherWaitTimeout caps how long mcpproxy will wait for a locally-launched
+	// HTTP/SSE upstream's URL to become reachable after Spawn(). Only consulted
+	// when the server is configured with both Command and an HTTP/SSE URL — i.e.,
+	// mcpproxy starts the process AND connects via network. Stdio servers ignore
+	// this field. Zero or unset → 30s default.
+	LauncherWaitTimeout Duration `json:"launcher_wait_timeout,omitempty" mapstructure:"launcher_wait_timeout" swaggertype:"string"`
 }
 
 // OAuthConfig represents OAuth configuration for a server

internal/config/merge.go

@@ -528,17 +528,18 @@ func CopyServerConfig(src *ServerConfig) *ServerConfig {
 	}
 
 	dst := &ServerConfig{
-		Name:           src.Name,
-		URL:            src.URL,
-		Protocol:       src.Protocol,
-		Command:        src.Command,
-		WorkingDir:     src.WorkingDir,
-		Enabled:        src.Enabled,
-		Quarantined:    src.Quarantined,
-		SkipQuarantine: src.SkipQuarantine,
-		Shared:         src.Shared,
-		Created:        src.Created,
-		Updated:        src.Updated,
+		Name:                src.Name,
+		URL:                 src.URL,
+		Protocol:            src.Protocol,
+		Command:             src.Command,
+		WorkingDir:          src.WorkingDir,
+		Enabled:             src.Enabled,
+		Quarantined:         src.Quarantined,
+		SkipQuarantine:      src.SkipQuarantine,
+		Shared:              src.Shared,
+		Created:             src.Created,
+		Updated:             src.Updated,
+		LauncherWaitTimeout: src.LauncherWaitTimeout,
 	}
 
 	// Copy slices

internal/upstream/core/client.go

@@ -19,6 +19,7 @@ import (
 	"github.com/smart-mcp-proxy/mcpproxy-go/internal/secret"
 	"github.com/smart-mcp-proxy/mcpproxy-go/internal/secureenv"
 	"github.com/smart-mcp-proxy/mcpproxy-go/internal/storage"
+	"github.com/smart-mcp-proxy/mcpproxy-go/internal/upstream/launcher"
 	"github.com/smart-mcp-proxy/mcpproxy-go/internal/upstream/types"
 
 	"github.com/mark3labs/mcp-go/client"
@@ -98,6 +99,14 @@ type Client struct {
 	containerName   string // Store container name for cleanup via docker container commands
 	isDockerCommand bool
 
+	// Local launcher tracking — only populated when this Client is using
+	// HTTP/SSE/streamable-HTTP transport AND ServerConfig.Command is set.
+	// In that mode mcpproxy spawns the upstream process before connecting,
+	// and owns its lifecycle via the handle below. Stdio servers leave
+	// these fields nil — they spawn through mcp-go's stdio transport.
+	launcherHandle  launcher.Handle
+	launcherCIDFile string
+
 	// Notification callback for tools/list_changed
 	onToolsChanged func(serverName string)
 }

internal/upstream/core/connection.go

@@ -3,6 +3,7 @@ package core
 import (
 	"context"
 	"fmt"
+	"os"
 	"time"
 
 	"github.com/smart-mcp-proxy/mcpproxy-go/internal/transport"
@@ -118,6 +119,21 @@ func (c *Client) Connect(ctx context.Context) error {
 
 	// Create and connect client based on transport type
 	var err error
+	// Locally-launched HTTP/SSE upstreams: spawn the child process before
+	// the transport-level connect, then wait for its URL to become
+	// reachable. Stdio is excluded because the stdio transport spawns
+	// through mcp-go itself; running the launcher here would double-spawn.
+	switch c.transportType {
+	case transportHTTP, transportHTTPStreamable, transportSSE:
+		if c.config.Command != "" {
+			c.logger.Debug("🚀 Launching local upstream before HTTP/SSE connect",
+				zap.String("server", c.config.Name),
+				zap.String("transport", c.transportType))
+			if launchErr := c.connectWithLauncher(ctx); launchErr != nil {
+				return fmt.Errorf("failed to launch local upstream: %w", launchErr)
+			}
+		}
+	}
 	switch c.transportType {
 	case transportStdio:
 		c.logger.Debug("📡 Using STDIO transport")
@@ -183,6 +199,36 @@ func (c *Client) Connect(ctx context.Context) error {
 			c.processGroupID = 0
 		}
 
+		// Stop any locally-launched upstream child the HTTP/SSE path
+		// started — connectWithLauncher itself only stops it on
+		// wait-for-url failure, not on subsequent transport-level
+		// connect failure.
+		//
+		// IMPORTANT: c.mu is held for the duration of Connect (see
+		// the c.mu.Lock at the top of this function), so we can read
+		// the launcher fields directly. We release the lock briefly
+		// around handle.Stop because Stop blocks until the child is
+		// reaped and we don't want to hold c.mu that long; the
+		// `connecting` flag already prevents a concurrent Connect.
+		if c.launcherHandle != nil {
+			handle := c.launcherHandle
+			cidFile := c.launcherCIDFile
+			c.launcherHandle = nil
+			c.launcherCIDFile = ""
+			c.mu.Unlock()
+			stopCtx, stopCancel := context.WithTimeout(context.Background(), 10*time.Second)
+			if stopErr := handle.Stop(stopCtx); stopErr != nil {
+				c.logger.Warn("error stopping launcher during connect-failure cleanup",
+					zap.String("server", c.config.Name),
+					zap.Error(stopErr))
+			}
+			stopCancel()
+			if cidFile != "" {
+				_ = os.Remove(cidFile)
+			}
+			c.mu.Lock()
+		}
+
 		return fmt.Errorf("failed to connect: %w", err)
 	}