fix: expand global proxy without losing projects

- recreate proxy with the union of listener ports and networks
- restore complete Caddy apps after listener expansion
- clear global network across recursive directory contexts

Author: dbpolito

commands/root.go

@@ -234,6 +234,7 @@ func clearDirectoryEnvironment(directory string) func() {
 		"KOOL_WORKSPACE_SOURCE", "KOOL_WORKSPACE_SOURCE_PROJECT", "KOOL_WORKSPACE_NAME",
 		"KOOL_WORKSPACE_PATH", "KOOL_WORKSPACE_PROJECT", "KOOL_WORKSPACE_SERVICES",
 		"KOOL_PROXY_DOMAIN", "KOOL_PROXY_HOST", "COMPOSE_PROJECT_NAME", "COMPOSE_FILE",
+		"KOOL_GLOBAL_NETWORK",
 	}
 	keys = append(keys, environment.LoadedEnvKeys(directory)...)
 	for _, key := range keys {

commands/root_test.go

@@ -275,6 +275,30 @@ func TestRecursiveWorkingDirectoryReplacesParentEnvironment(t *testing.T) {
 	}
 }
 
+func TestRecursiveWorkingDirectoryReplacesGlobalNetwork(t *testing.T) {
+	originalDirectory, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	parent := t.TempDir()
+	target := t.TempDir()
+	if err = os.WriteFile(filepath.Join(target, ".env"), []byte("KOOL_GLOBAL_NETWORK=target_network\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("KOOL_GLOBAL_NETWORK", "kool_global")
+	restore := clearDirectoryEnvironment(parent)
+	defer restore()
+	if err := os.Chdir(target); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(originalDirectory) })
+	env := environment.NewEnvStorage()
+	environment.InitEnvironmentVariables(env)
+	if got := env.Get("KOOL_GLOBAL_NETWORK"); got != "target_network" {
+		t.Fatalf("expected target global network, got %q", got)
+	}
+}
+
 func TestRecursiveCall(t *testing.T) {
 	recursive := &cobra.Command{
 		Use: "recursive",

services/proxy/manager.go

@@ -431,6 +431,10 @@ func (m *DefaultManager) createAliasOverride(network string, routes []route) (st
 func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 	inspect := builder.NewCommand("docker", "inspect", "--format", "{{.State.Running}}", caddyContainer)
 	running, err := m.shell.Exec(inspect)
+	ports := make(map[int]bool)
+	var preservedApps []byte
+	var preservedAppsExist bool
+	var preservedNetworks []string
 	if err == nil {
 		compatibility, inspectErr := m.shell.Exec(builder.NewCommand("docker", "inspect", "--format", "{{json .NetworkSettings.Networks}}|{{json .Config.Entrypoint}}|{{json .Config.Cmd}}", caddyContainer))
 		if inspectErr != nil {
@@ -442,6 +446,33 @@ func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 				return err
 			}
 			err = errors.New("legacy proxy container removed")
+		} else {
+			for _, route := range routes {
+				if _, portErr := m.shell.Exec(builder.NewCommand("docker", "port", caddyContainer), fmt.Sprintf("%d/tcp", route.Listen)); portErr == nil {
+					ports[route.Listen] = true
+					continue
+				}
+				if preservedApps, preservedAppsExist, err = m.snapshotApps(); err != nil {
+					return err
+				}
+				bindings, inspectErr := m.shell.Exec(builder.NewCommand("docker", "inspect", "--format", "{{json .HostConfig.PortBindings}}", caddyContainer))
+				if inspectErr != nil {
+					return inspectErr
+				}
+				for port := range parseContainerPorts(bindings) {
+					ports[port] = true
+				}
+				networks, inspectErr := m.shell.Exec(builder.NewCommand("docker", "inspect", "--format", "{{json .NetworkSettings.Networks}}", caddyContainer))
+				if inspectErr != nil {
+					return inspectErr
+				}
+				preservedNetworks = parseDockerObjectKeys(networks)
+				if err = m.shell.Interactive(builder.NewCommand("docker", "rm", "--force"), caddyContainer); err != nil {
+					return err
+				}
+				err = errors.New("proxy listener expansion required")
+				break
+			}
 		}
 	}
 	if err != nil {
@@ -455,7 +486,6 @@ func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 			}
 		}
 		args := []string{"run", "-d", "--name", caddyContainer, "--restart", "unless-stopped", "--network", caddyAdminNet, "--network-alias", caddyAdminHost, "-p", "127.0.0.1:2019:2019"}
-		ports := make(map[int]bool)
 		for _, route := range routes {
 			ports[route.Listen] = true
 		}
@@ -494,6 +524,14 @@ func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 			return err
 		}
 	}
+	for _, previousNetwork := range preservedNetworks {
+		if previousNetwork == caddyAdminNet || previousNetwork == network {
+			continue
+		}
+		if err = m.shell.Interactive(builder.NewCommand("docker", "network", "connect", previousNetwork), caddyContainer); err != nil {
+			return err
+		}
+	}
 
 	for _, route := range routes {
 		if _, err = m.shell.Exec(builder.NewCommand("docker", "port", caddyContainer), fmt.Sprintf("%d/tcp", route.Listen)); err != nil {
@@ -505,6 +543,9 @@ func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 		if requestErr == nil {
 			_ = response.Body.Close()
 			if response.StatusCode < 500 {
+				if preservedAppsExist {
+					return m.restoreApps(preservedApps, true)
+				}
 				return nil
 			}
 		}
@@ -513,6 +554,34 @@ func (m *DefaultManager) ensureCaddy(network string, routes []route) error {
 	return errors.New("kool proxy did not become ready")
 }
 
+func parseContainerPorts(raw string) map[int]bool {
+	ports := make(map[int]bool)
+	var bindings map[string]interface{}
+	if json.Unmarshal([]byte(raw), &bindings) != nil {
+		return ports
+	}
+	for key := range bindings {
+		port, err := strconv.Atoi(strings.TrimSuffix(key, "/tcp"))
+		if err == nil {
+			ports[port] = true
+		}
+	}
+	return ports
+}
+
+func parseDockerObjectKeys(raw string) []string {
+	var object map[string]interface{}
+	if json.Unmarshal([]byte(raw), &object) != nil {
+		return nil
+	}
+	keys := make([]string, 0, len(object))
+	for key := range object {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
 func (m *DefaultManager) ensureBaseConfig() (string, error) {
 	home, err := os.UserHomeDir()
 	if err != nil {

services/proxy/manager_test.go

@@ -758,6 +758,18 @@ func TestProxyCompatibilityRequiresSecureStoredCommand(t *testing.T) {
 	}
 }
 
+func TestParseExistingProxyPortsAndNetworks(t *testing.T) {
+	ports := parseContainerPorts(`{"80/tcp":[{}],"3001/tcp":[{}]}`)
+	if !ports[80] || !ports[3001] || len(ports) != 2 {
+		t.Fatalf("expected existing proxy ports to be preserved, got %v", ports)
+	}
+	networks := parseDockerObjectKeys(`{"project_b":{},"kool_proxy_admin":{},"project_a":{}}`)
+	expected := []string{"kool_proxy_admin", "project_a", "project_b"}
+	if strings.Join(networks, ",") != strings.Join(expected, ",") {
+		t.Fatalf("expected sorted existing networks %v, got %v", expected, networks)
+	}
+}
+
 func TestRestoreAppsIfUnchangedPreservesConcurrentUpdate(t *testing.T) {
 	current := []byte(`{"http":{"servers":{"current":{}}}}`)
 	restored := false