Merge devtunnel create+host into single operation with server port

DevTunnelCreate now creates the tunnel, hosts the relay, and forwards
the linkspan server port in one step — giving the client direct HTTP
access to linkspan immediately. Additional service ports (SSH, etc.)
are added incrementally via DevTunnelForward.

- Remove DevTunnelHost as separate function (merged into DevTunnelCreate)
- Remove tunnel.devtunnel_host workflow action
- Remove unused toIntSlice helper
- Workflow is now 3 steps: create → create_session → forward
- Add binaries to .gitignore

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: yasithdev

.gitignore

@@ -2,3 +2,5 @@ tmp/
 bin/
 # Added by goreleaser init:
 dist/
+linkspan
+linkspan-linux-amd64

examples/cs-bridge-workflow.yaml

@@ -7,15 +7,9 @@ steps:
       tunnel_name: "linkspan-tunnel"
       expiration: "1d"
       auth_token: "{{.TunnelAuthToken}}"
+      server_port: "{{.ServerPort}}"
     outputs:
       tunnel_id: "tunnel_id"
-
-  - action: "tunnel.devtunnel_host"
-    name: "Host devtunnel"
-    params:
-      tunnel_name: "linkspan-tunnel"
-      auth_token: "{{.TunnelAuthToken}}"
-    outputs:
       connection_url: "tunnel_url"
       token: "tunnel_token"
 

internal/workflow/actions.go

@@ -15,7 +15,6 @@ import (
 func registerBuiltinActions(r *Registry) {
 	r.Register("vscode.create_session", actionVSCodeCreateSession)
 	r.Register("tunnel.devtunnel_create", actionDevTunnelCreate)
-	r.Register("tunnel.devtunnel_host", actionDevTunnelHost)
 	r.Register("tunnel.devtunnel_forward", actionDevTunnelForward)
 	r.Register("tunnel.devtunnel_delete", actionDevTunnelDelete)
 	r.Register("tunnel.devtunnel_connect", actionDevTunnelConnect)
@@ -44,6 +43,9 @@ func actionVSCodeCreateSession(params map[string]any) (*ActionResult, error) {
 }
 
 // --- tunnel.devtunnel_create ---
+// Creates a tunnel, hosts the relay, and forwards the server port so the client
+// can communicate with linkspan immediately.  Additional ports are added later
+// via tunnel.devtunnel_forward.
 
 func actionDevTunnelCreate(params map[string]any) (*ActionResult, error) {
 	tunnelName, _ := params["tunnel_name"].(string)
@@ -55,35 +57,16 @@ func actionDevTunnelCreate(params map[string]any) (*ActionResult, error) {
 	if authToken == "" {
 		return nil, fmt.Errorf("tunnel.devtunnel_create: auth_token is required")
 	}
+	serverPort := toInt(params["server_port"])
 
-	info, err := tunnel.DevTunnelCreate(tunnelName, expiration, authToken)
+	conn, err := tunnel.DevTunnelCreate(tunnelName, expiration, authToken, serverPort)
 	if err != nil {
 		return nil, err
 	}
 
 	result := ActionResult{
-		"tunnel_id":   info.QualifiedID(),
-		"tunnel_name": info.TunnelName,
-	}
-	return &result, nil
-}
-
-// --- tunnel.devtunnel_host ---
-
-func actionDevTunnelHost(params map[string]any) (*ActionResult, error) {
-	tunnelName, _ := params["tunnel_name"].(string)
-	authToken, _ := params["auth_token"].(string)
-	if authToken == "" {
-		return nil, fmt.Errorf("tunnel.devtunnel_host: auth_token is required")
-	}
-
-	cmdID, conn, err := tunnel.DevTunnelHost(tunnelName, authToken)
-	if err != nil {
-		return nil, err
-	}
-
-	result := ActionResult{
-		"command_id":     cmdID,
+		"tunnel_id":      conn.DevTunnelInfo.QualifiedID(),
+		"tunnel_name":    conn.DevTunnelInfo.TunnelName,
 		"connection_url": conn.ConnectionURL,
 		"token":          conn.Token,
 	}
@@ -202,22 +185,6 @@ func actionShellExec(params map[string]any) (*ActionResult, error) {
 
 // --- helpers ---
 
-// toIntSlice converts a param value to []int, handling YAML-decoded []any.
-func toIntSlice(v any) []int {
-	switch val := v.(type) {
-	case []any:
-		out := make([]int, 0, len(val))
-		for _, elem := range val {
-			out = append(out, toInt(elem))
-		}
-		return out
-	case []int:
-		return val
-	default:
-		return nil
-	}
-}
-
 // toInt converts a param value to int, handling YAML's default float64/int types.
 func toInt(v any) int {
 	switch val := v.(type) {

main.go

@@ -196,24 +196,15 @@ func main() {
 
 				ch := make(chan error, 1)
 				go func() {
-					_, err := tunnel.DevTunnelCreate(tunnelName, "1d", authToken)
+					conn, err := tunnel.DevTunnelCreate(tunnelName, "1d", authToken, serverPort)
 					if err != nil {
 						ch <- err
 						return
 					}
-					_, tunnelConnection, err := tunnel.DevTunnelHost(tunnelName, authToken)
-					if err != nil {
-						ch <- err
-						return
-					}
-					if err := tunnel.DevTunnelForward(tunnelName, serverPort, authToken); err != nil {
-						ch <- err
-						return
-					}
 
-					log.Printf("Connect to agent using the URL: %s", tunnelConnection.ConnectionURL)
-					log.Printf("DevTunnel ID: %s", tunnelConnection.DevTunnelInfo.TunnelID)
-					log.Printf("DevTunnel Token: %s", tunnelConnection.Token)
+					log.Printf("Connect to agent using the URL: %s", conn.ConnectionURL)
+					log.Printf("DevTunnel ID: %s", conn.DevTunnelInfo.TunnelID)
+					log.Printf("DevTunnel Token: %s", conn.Token)
 					ch <- nil
 				}()
 

subsystems/tunnel/api.go

@@ -24,14 +24,16 @@ type DevTunnelCreateRequest struct {
 	// AuthToken is the Microsoft Entra ID (Azure AD) bearer token used to
 	// authenticate against the Dev Tunnels service.  It is required for all
 	// devtunnel operations.
-	AuthToken string `json:"authToken"`
+	AuthToken  string `json:"authToken"`
+	ServerPort int    `json:"serverPort"` // linkspan HTTP port to forward immediately
 }
 
 // DevTunnelCreateResponse is the JSON body returned after a successful create+host.
 type DevTunnelCreateResponse struct {
-	TunnelName string `json:"tunnelName"`
-	TunnelID   string `json:"tunnelID"`
-	Token      string `json:"token,omitempty"`
+	TunnelName    string `json:"tunnelName"`
+	TunnelID      string `json:"tunnelID"`
+	ConnectionURL string `json:"connectionURL,omitempty"`
+	Token         string `json:"token,omitempty"`
 }
 
 // FrpTunnelProxyCreateRequest is the JSON body for POST /tunnels/frp.
@@ -71,7 +73,8 @@ func ListDevTunnels(w http.ResponseWriter, r *http.Request) {
 }
 
 // CreateDevTunnel handles POST /tunnels/devtunnel.
-// It creates the tunnel via the SDK and immediately starts hosting it via the CLI.
+// Creates the tunnel, hosts the relay, and forwards the server port so the
+// client can communicate with linkspan immediately.
 func CreateDevTunnel(w http.ResponseWriter, r *http.Request) {
 	var req DevTunnelCreateRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -85,22 +88,17 @@ func CreateDevTunnel(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	info, err := DevTunnelCreate(req.TunnelName, req.Expiration, req.AuthToken)
-	if err != nil {
-		utils.RespondJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
-		return
-	}
-
-	_, connection, err := DevTunnelHost(req.TunnelName, req.AuthToken)
+	conn, err := DevTunnelCreate(req.TunnelName, req.Expiration, req.AuthToken, req.ServerPort)
 	if err != nil {
 		utils.RespondJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 		return
 	}
 
 	utils.RespondJSON(w, http.StatusCreated, DevTunnelCreateResponse{
-		TunnelName: req.TunnelName,
-		TunnelID:   info.TunnelID,
-		Token:      connection.Token,
+		TunnelName:    req.TunnelName,
+		TunnelID:      conn.DevTunnelInfo.TunnelID,
+		ConnectionURL: conn.ConnectionURL,
+		Token:         conn.Token,
 	})
 }
 

subsystems/tunnel/devtunnel.go

@@ -8,17 +8,20 @@ import (
 	pm "github.com/cyber-shuttle/linkspan/internal/process"
 )
 
-// DevTunnelCreate creates a tunnel on the service (no ports registered yet)
-// and registers it with GlobalDevTunnelManager.
-func DevTunnelCreate(tunnelName string, expiration string, authToken string) (DevTunnelInfo, error) {
+// DevTunnelCreate creates a tunnel, starts hosting the relay, and forwards the
+// given serverPort so the client can communicate with linkspan immediately.
+// Additional ports (e.g. SSH) can be added later via DevTunnelForward.
+func DevTunnelCreate(tunnelName string, expiration string, authToken string, serverPort int) (DevTunnelConnection, error) {
 	if err := InitSDK(authToken); err != nil {
-		return DevTunnelInfo{}, fmt.Errorf("devtunnel create: init SDK: %w", err)
+		return DevTunnelConnection{}, fmt.Errorf("devtunnel create: init SDK: %w", err)
 	}
 
 	ctx := context.Background()
+
+	// 1. Create the tunnel on the service.
 	sdkTunnel, err := SDKCreateTunnel(ctx, tunnelName)
 	if err != nil {
-		return DevTunnelInfo{}, fmt.Errorf("devtunnel create %q: %w", tunnelName, err)
+		return DevTunnelConnection{}, fmt.Errorf("devtunnel create %q: %w", tunnelName, err)
 	}
 
 	info := &DevTunnelInfo{
@@ -32,52 +35,43 @@ func DevTunnelCreate(tunnelName string, expiration string, authToken string) (De
 		log.Printf("devtunnel create: warning — failed to register %q in manager: %v", tunnelName, err)
 	}
 
-	log.Printf("devtunnel create: tunnel %q ready (id=%s)", tunnelName, sdkTunnel.TunnelID)
-	return *info, nil
-}
-
-// DevTunnelHost starts hosting the tunnel relay connection.
-// No ports are forwarded yet — use DevTunnelForward to add port forwarding.
-func DevTunnelHost(tunnelName string, authToken string) (string, DevTunnelConnection, error) {
-	if err := InitSDK(authToken); err != nil {
-		return "", DevTunnelConnection{}, fmt.Errorf("devtunnel host: init SDK: %w", err)
-	}
-
-	devTunInfo, err := GlobalDevTunnelManager.Find(tunnelName)
-	if err != nil {
-		return "", DevTunnelConnection{}, fmt.Errorf("devtunnel host: tunnel %q not registered: %w", tunnelName, err)
+	// 2. Register the server port so it is forwarded through the tunnel.
+	if serverPort > 0 {
+		if err := SDKAddPort(ctx, tunnelName, serverPort); err != nil {
+			return DevTunnelConnection{}, fmt.Errorf("devtunnel create: add server port %d to %q: %w", serverPort, tunnelName, err)
+		}
+		info.Ports = append(info.Ports, serverPort)
 	}
 
-	ctx := context.Background()
-
+	// 3. Obtain host token and start the relay with the server port forwarded.
 	hostToken, err := SDKGetHostToken(ctx, tunnelName)
 	if err != nil {
-		return "", DevTunnelConnection{}, fmt.Errorf("devtunnel host: get host token for %q: %w", tunnelName, err)
+		return DevTunnelConnection{}, fmt.Errorf("devtunnel create: get host token for %q: %w", tunnelName, err)
 	}
 
-	// Host without ports — all port forwarding is done later via DevTunnelForward.
-	cmdID, connectionURL, err := CLIHostTunnel(devTunInfo.TunnelID, hostToken, nil)
+	cmdID, connectionURL, err := CLIHostTunnel(info.TunnelID, hostToken, info.Ports)
 	if err != nil {
-		return "", DevTunnelConnection{}, fmt.Errorf("devtunnel host: start CLI for %q: %w", tunnelName, err)
+		return DevTunnelConnection{}, fmt.Errorf("devtunnel create: start host for %q: %w", tunnelName, err)
 	}
 
-	// Track the host process command ID so DevTunnelForward can restart it.
-	devTunInfo.HostCmdID = cmdID
-	devTunInfo.HostToken = hostToken
+	info.HostCmdID = cmdID
+	info.HostToken = hostToken
 
 	conn := DevTunnelConnection{
 		ConnectionURL: connectionURL,
-		DevTunnelInfo: devTunInfo,
+		DevTunnelInfo: info,
 	}
 
+	// 4. Get a connect token for the client side.
 	connectToken, tokenErr := SDKGetConnectToken(ctx, tunnelName)
 	if tokenErr != nil {
-		log.Printf("devtunnel host: warning — could not obtain connect token for %q: %v", tunnelName, tokenErr)
+		log.Printf("devtunnel create: warning — could not obtain connect token for %q: %v", tunnelName, tokenErr)
 	} else {
 		conn.Token = connectToken
 	}
 
-	return cmdID, conn, nil
+	log.Printf("devtunnel create: tunnel %q ready (id=%s, url=%s, port=%d)", tunnelName, sdkTunnel.TunnelID, connectionURL, serverPort)
+	return conn, nil
 }
 
 // DevTunnelForward adds port forwarding to an existing hosted tunnel.
@@ -116,7 +110,6 @@ func DevTunnelForward(tunnelName string, port int, authToken string) error {
 
 		hostToken := devTunInfo.HostToken
 		if hostToken == "" {
-			// Re-fetch if not cached (shouldn't happen in normal flow).
 			hostToken, err = SDKGetHostToken(ctx, tunnelName)
 			if err != nil {
 				return fmt.Errorf("devtunnel forward: get host token for %q: %w", tunnelName, err)

subsystems/tunnel/devtunnel_test.go

@@ -19,7 +19,7 @@ func authTokenForTest(t *testing.T) string {
 	return token
 }
 
-func TestDevTunnelConnect(t *testing.T) {
+func TestDevTunnelCreateAndHost(t *testing.T) {
 	authToken := authTokenForTest(t)
 	tunnelName := "test-tunnel"
 
@@ -30,42 +30,40 @@ func TestDevTunnelConnect(t *testing.T) {
 		}
 	}()
 
-	_, err := DevTunnelCreate(tunnelName, "1d", authToken)
+	conn, err := DevTunnelCreate(tunnelName, "1d", authToken, 8080)
 	if err != nil {
 		t.Fatalf("failed to create dev tunnel: %v", err)
-	} else {
-		t.Logf("dev tunnel created successfully")
 	}
+	t.Logf("dev tunnel created+hosted: url=%s token=%s", conn.ConnectionURL, conn.Token)
 
-	tunnelCommandId, tunnelConnection, err := DevTunnelHost(tunnelName, authToken)
-	if err != nil {
-		t.Fatalf("failed to set up dev tunnel: %v", err)
-	} else {
-		t.Logf("dev tunnel set up successfully: %+v", tunnelConnection)
+	if conn.DevTunnelInfo.HostCmdID == "" {
+		t.Fatal("expected host command ID to be set")
 	}
 
-	err = pm.GlobalProcessManager.Kill(tunnelCommandId)
+	err = pm.GlobalProcessManager.Kill(conn.DevTunnelInfo.HostCmdID)
 	if err != nil {
-		t.Fatalf("failed to stop dev tunnel command with id %s: %v", tunnelCommandId, err)
-	} else {
-		t.Logf("dev tunnel command with id %s stopped successfully", tunnelCommandId)
+		t.Fatalf("failed to stop dev tunnel host: %v", err)
 	}
+	t.Logf("dev tunnel host stopped successfully")
 }
 
-func TestDevTunnelCreate(t *testing.T) {
+func TestDevTunnelCreateNoPort(t *testing.T) {
 	authToken := authTokenForTest(t)
+	tunnelName := "test-tunnel-noport"
 
-	_, err := DevTunnelCreate("test-tunnel", "1d", authToken)
+	conn, err := DevTunnelCreate(tunnelName, "1d", authToken, 0)
 	if err != nil {
 		t.Fatalf("failed to create dev tunnel: %v", err)
-	} else {
-		t.Logf("dev tunnel created successfully")
+	}
+	t.Logf("dev tunnel created: url=%s", conn.ConnectionURL)
+
+	if conn.DevTunnelInfo.HostCmdID != "" {
+		_ = pm.GlobalProcessManager.Kill(conn.DevTunnelInfo.HostCmdID)
 	}
 
-	err = DevTunnelDelete("test-tunnel", authToken)
+	err = DevTunnelDelete(tunnelName, authToken)
 	if err != nil {
 		t.Fatalf("failed to delete dev tunnel: %v", err)
-	} else {
-		t.Logf("dev tunnel deleted successfully")
 	}
+	t.Logf("dev tunnel deleted successfully")
 }