Support Docker bridge networking and Kubo URL env

Add detection of the container's own bridge IP for proxy targets and environment-driven Kubo API address handling.

blox/kubo_proxy.go: add a new detection step that iterates local interfaces (skipping lo, docker*, br-*, veth) to find the container's bridge IPv4 and return it as the proxy target; keep existing docker0/br-* detection and fallback to 127.0.0.1. Adds an informational log when a container bridge IP is detected.

cmd/blox/main.go: read KUBO_API_URL (default http://127.0.0.1:5001), parse host:port, resolve host via DNS to an IP (to support Docker DNS names like "kubo"), construct the IP-based multiaddr, and pass the kubo address into the blox options via WithKuboAPIAddr. Also adds a strings import. These changes enable running go-fula inside bridge-networked containers and using docker-compose service names for the Kubo API.

Author: ehsan6sha

blox/kubo_proxy.go

@@ -67,7 +67,8 @@ func getProtocols() []p2pProtocol {
 // Detection order:
 //  1. docker0 interface IPv4 address (Docker default bridge gateway)
 //  2. Any Docker Compose bridge (br-<hash>) IPv4 address
-//  3. Fallback to 127.0.0.1 (works when kubo is also on host network)
+//  3. Container's own bridge IP (when go-fula runs inside a bridge-networked container)
+//  4. Fallback to 127.0.0.1 (works when kubo is also on host network)
 func resolveProxyTargetIP() string {
 	// 1. Try docker0 (default Docker bridge)
 	if ip := getIPv4FromInterface("docker0"); ip != "" {
@@ -88,7 +89,29 @@ func resolveProxyTargetIP() string {
 		}
 	}
 
-	// 3. Fallback
+	// 3. Container's own bridge IP (Docker bridge networking mode).
+	// When go-fula runs inside a container on a bridge network,
+	// docker0/br-* don't exist inside the container. Use the container's
+	// own IPv4 on its bridge interface (typically eth0), which is reachable
+	// from other containers on the same Docker Compose network.
+	if ifaces == nil {
+		ifaces, _ = net.Interfaces()
+	}
+	if ifaces != nil {
+		for _, iface := range ifaces {
+			if iface.Name == "lo" || strings.HasPrefix(iface.Name, "docker") ||
+				strings.HasPrefix(iface.Name, "br-") || strings.HasPrefix(iface.Name, "veth") {
+				continue
+			}
+			if ip := getIPv4FromInterface(iface.Name); ip != "" {
+				log.Infow("Detected container bridge IP for proxy target (bridge networking mode)",
+					"iface", iface.Name, "ip", ip)
+				return ip
+			}
+		}
+	}
+
+	// 4. Fallback
 	log.Debug("No Docker bridge interface found, using 127.0.0.1 for proxy target")
 	return "127.0.0.1"
 }

cmd/blox/main.go

@@ -20,6 +20,7 @@ import (
 	"path"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -1089,7 +1090,23 @@ func action(ctx *cli.Context) error {
 	linkSystem := cidlink.DefaultLinkSystem()
 	linkSystem.StorageReadOpener = CustomStorageReadOpenerNone
 	linkSystem.StorageWriteOpener = CustomStorageWriteOpenerNone
-	nodeMultiAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/5001")
+
+	// Read kubo API address from env (set in docker-compose.pc.yml for bridge networking)
+	kuboURL := os.Getenv("KUBO_API_URL")
+	if kuboURL == "" {
+		kuboURL = "http://127.0.0.1:5001"
+	}
+	kuboHostPort := strings.TrimPrefix(kuboURL, "http://")
+	kuboHost, kuboPort, err := net.SplitHostPort(kuboHostPort)
+	if err != nil {
+		kuboHost = kuboHostPort
+		kuboPort = "5001"
+	}
+	// Resolve hostname to IP for multiaddr (Docker DNS names like "kubo" → container IP)
+	if ips, err := net.LookupHost(kuboHost); err == nil && len(ips) > 0 {
+		kuboHost = ips[0]
+	}
+	nodeMultiAddr, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%s", kuboHost, kuboPort))
 	if err != nil {
 		panic(fmt.Errorf("invalid multiaddress: %w", err))
 	}
@@ -1136,6 +1153,7 @@ func action(ctx *cli.Context) error {
 		blox.WithIpfsClient(node),
 		blox.WithPoolHostMode(app.poolHost),
 		blox.WithIpfsClusterAPI(ipfsClusterApi),
+		blox.WithKuboAPIAddr(kuboHostPort),
 	)
 	if err != nil {
 		return err