Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

refactor(config): extract httpPortFromEnv and envURL from LoadEndpoints (#425)

fx-kurumiab901ddce370
diff --git a/internal/config/endpoints.go b/internal/config/endpoints.go
index eda1db29..106cb327 100644
--- a/internal/config/endpoints.go
+++ b/internal/config/endpoints.go
@@ -47,31 +47,38 @@ func LoadEndpoints(role, addrFlag string) (Endpoints, error) {
Role: role,
PlatformMCPToken: env("AGENTFLOW_PLATFORM_MCP_TOKEN"),
ControlToken: env("AGENTFLOW_CONTROL_TOKEN"),
- WorkerFallbackURL: trimURL(env("AGENTFLOW_WORKER_URL")),
+ WorkerFallbackURL: envURL("AGENTFLOW_WORKER_URL"),
}
- httpPort := env("AGENTFLOW_HTTP_PORT")
- if httpPort == "" {
- httpPort = defaultAPIPort
- }
- if n, err := strconv.Atoi(httpPort); err != nil || n < 1 || n > 65535 {
- return Endpoints{}, fmt.Errorf("invalid AGENTFLOW_HTTP_PORT %q", httpPort)
+ httpPort, err := httpPortFromEnv()
+ if err != nil {
+ return Endpoints{}, err
}
- configuredAPI := trimURL(env("AGENTFLOW_API_URL"))
+ configuredAPI := envURL("AGENTFLOW_API_URL")
if role == "worker" {
ep.ListenAddr = firstNonEmpty(addrFlag, defaultWorkerAddr)
- ep.ControlURL = firstNonEmpty(trimURL(env("AGENTFLOW_CONTROL_URL")), LoopbackURL(ep.ListenAddr))
+ ep.ControlURL = firstNonEmpty(envURL("AGENTFLOW_CONTROL_URL"), LoopbackURL(ep.ListenAddr))
ep.APIBase = firstNonEmpty(configuredAPI, "http://127.0.0.1:"+httpPort)
- ep.PlatformBase = firstNonEmpty(trimURL(env("AGENTFLOW_PLATFORM_MCP_URL")), configuredAPI)
+ ep.PlatformBase = firstNonEmpty(envURL("AGENTFLOW_PLATFORM_MCP_URL"), configuredAPI)
} else {
ep.ListenAddr = firstNonEmpty(addrFlag, ":"+httpPort)
ep.APIBase = firstNonEmpty(configuredAPI, LoopbackURL(ep.ListenAddr))
- ep.PlatformBase = firstNonEmpty(trimURL(env("AGENTFLOW_PLATFORM_MCP_URL")), ep.APIBase)
+ ep.PlatformBase = firstNonEmpty(envURL("AGENTFLOW_PLATFORM_MCP_URL"), ep.APIBase)
}
- ep.AgentToolGateway = firstNonEmpty(trimURL(env("AGENTFLOW_AGENT_TOOL_GATEWAY_URL")), ep.APIBase)
+ ep.AgentToolGateway = firstNonEmpty(envURL("AGENTFLOW_AGENT_TOOL_GATEWAY_URL"), ep.APIBase)
ep.CollectorBase = firstNonEmpty(ep.PlatformBase, ep.APIBase)
return ep, nil
}
+// httpPortFromEnv returns AGENTFLOW_HTTP_PORT, defaulting to defaultAPIPort,
+// and rejects values that are not a TCP port number.
+func httpPortFromEnv() (string, error) {
+ port := firstNonEmpty(env("AGENTFLOW_HTTP_PORT"), defaultAPIPort)
+ if n, err := strconv.Atoi(port); err != nil || n < 1 || n > 65535 {
+ return "", fmt.Errorf("invalid AGENTFLOW_HTTP_PORT %q", port)
+ }
+ return port, nil
+}
+
// WithPrivateAgentToolGateway points native agent-tool callbacks at base, the
// process's own loopback listener: tool sessions live in process memory, so
// after a handover a CLI must keep calling the process that started it.
@@ -137,6 +144,9 @@ func env(key string) string { return strings.TrimSpace(os.Getenv(key)) }
func trimURL(u string) string { return strings.TrimRight(strings.TrimSpace(u), "/") }
+// envURL reads key as a base URL: trimmed, without trailing slashes.
+func envURL(key string) string { return trimURL(env(key)) }
+
func firstNonEmpty(values ...string) string {
for _, v := range values {
if v = strings.TrimSpace(v); v != "" {
diff --git a/internal/config/endpoints_env_test.go b/internal/config/endpoints_env_test.go
new file mode 100644
index 00000000..1e079eec
--- /dev/null
+++ b/internal/config/endpoints_env_test.go
@@ -0,0 +1,58 @@
+package config
+
+import "testing"
+
+func TestHTTPPortFromEnv(t *testing.T) {
+ cases := []struct {
+ value string
+ want string
+ wantErr bool
+ }{
+ {value: "", want: defaultAPIPort},
+ {value: " ", want: defaultAPIPort},
+ {value: " 9090 ", want: "9090"},
+ {value: "1", want: "1"},
+ {value: "65535", want: "65535"},
+ {value: "0", wantErr: true},
+ {value: "65536", wantErr: true},
+ {value: "http", wantErr: true},
+ }
+ for _, tc := range cases {
+ t.Setenv("AGENTFLOW_HTTP_PORT", tc.value)
+ got, err := httpPortFromEnv()
+ if tc.wantErr {
+ if err == nil || err.Error() != `invalid AGENTFLOW_HTTP_PORT "`+tc.value+`"` {
+ t.Fatalf("httpPortFromEnv(%q) err = %v, want invalid port error", tc.value, err)
+ }
+ continue
+ }
+ if err != nil || got != tc.want {
+ t.Fatalf("httpPortFromEnv(%q) = %q, %v; want %q", tc.value, got, err, tc.want)
+ }
+ }
+}
+
+func TestLoadEndpointsRejectsInvalidPort(t *testing.T) {
+ clearEndpointEnv(t)
+ t.Setenv("AGENTFLOW_HTTP_PORT", "70000")
+ if _, err := LoadEndpoints("api", ""); err == nil {
+ t.Fatal("LoadEndpoints accepted an out-of-range AGENTFLOW_HTTP_PORT")
+ }
+}
+
+func TestEnvURL(t *testing.T) {
+ cases := map[string]string{
+ "": "",
+ " ": "",
+ "/": "",
+ " http://api.example/ ": "http://api.example",
+ "http://api.example/base//": "http://api.example/base",
+ "http://api.example/base": "http://api.example/base",
+ }
+ for value, want := range cases {
+ t.Setenv("AGENTFLOW_API_URL", value)
+ if got := envURL("AGENTFLOW_API_URL"); got != want {
+ t.Fatalf("envURL with %q = %q, want %q", value, got, want)
+ }
+ }
+}