chore: display source and destination types in connection output

- Add type display in brackets [TYPE] for connection list view
- Add 'Type:' field to connection get detailed view
- Update tests to verify type fields are displayed correctly

Author: leggetter

pkg/cmd/connection_get.go

@@ -88,6 +88,7 @@ func (cc *connectionGetCmd) runConnectionGetCmd(cmd *cobra.Command, args []strin
 			fmt.Printf("Source:\n")
 			fmt.Printf("  Name: %s\n", conn.Source.Name)
 			fmt.Printf("  ID: %s\n", conn.Source.ID)
+			fmt.Printf("  Type: %s\n", conn.Source.Type)
 			fmt.Printf("  URL: %s\n", conn.Source.URL)
 			fmt.Printf("\n")
 		}
@@ -97,6 +98,7 @@ func (cc *connectionGetCmd) runConnectionGetCmd(cmd *cobra.Command, args []strin
 			fmt.Printf("Destination:\n")
 			fmt.Printf("  Name: %s\n", conn.Destination.Name)
 			fmt.Printf("  ID: %s\n", conn.Destination.ID)
+			fmt.Printf("  Type: %s\n", conn.Destination.Type)
 
 			if cliPath := conn.Destination.GetCLIPath(); cliPath != nil {
 				fmt.Printf("  CLI Path: %s\n", *cliPath)

pkg/cmd/connection_list.go

@@ -142,23 +142,27 @@ func (cc *connectionListCmd) runConnectionListCmd(cmd *cobra.Command, args []str
 
 		sourceName := "unknown"
 		sourceID := "unknown"
+		sourceType := "unknown"
 		if conn.Source != nil {
 			sourceName = conn.Source.Name
 			sourceID = conn.Source.ID
+			sourceType = conn.Source.Type
 		}
 
 		destinationName := "unknown"
 		destinationID := "unknown"
+		destinationType := "unknown"
 		if conn.Destination != nil {
 			destinationName = conn.Destination.Name
 			destinationID = conn.Destination.ID
+			destinationType = conn.Destination.Type
 		}
 
 		// Show connection name in color
 		fmt.Printf("%s\n", color.Green(connectionName))
 		fmt.Printf("  ID: %s\n", conn.ID)
-		fmt.Printf("  Source: %s (%s)\n", sourceName, sourceID)
-		fmt.Printf("  Destination: %s (%s)\n", destinationName, destinationID)
+		fmt.Printf("  Source: %s (%s) [%s]\n", sourceName, sourceID, sourceType)
+		fmt.Printf("  Destination: %s (%s) [%s]\n", destinationName, destinationID, destinationType)
 
 		if conn.DisabledAt != nil {
 			fmt.Printf("  Status: %s\n", color.Red("disabled"))

test/acceptance/connection_list_test.go

@@ -249,6 +249,30 @@ func TestConnectionListFilters(t *testing.T) {
 		}
 
 		cli := NewCLIRunner(t)
+		timestamp := generateTimestamp()
+
+		connName := "test-human-output-" + timestamp
+		sourceName := "test-human-src-" + timestamp
+		destName := "test-human-dst-" + timestamp
+
+		// Create a connection to test output format
+		var conn Connection
+		err := cli.RunJSON(&conn,
+			"connection", "create",
+			"--name", connName,
+			"--source-name", sourceName,
+			"--source-type", "WEBHOOK",
+			"--destination-name", destName,
+			"--destination-type", "CLI",
+			"--destination-cli-path", "/webhooks",
+		)
+		require.NoError(t, err, "Should create connection")
+		require.NotEmpty(t, conn.ID, "Connection should have an ID")
+
+		// Cleanup
+		t.Cleanup(func() {
+			deleteConnection(t, cli, conn.ID)
+		})
 
 		// List without --output json to get human-readable format
 		stdout := cli.RunExpectSuccess("connection", "list")
@@ -258,6 +282,14 @@ func TestConnectionListFilters(t *testing.T) {
 			strings.Contains(stdout, "connection") || strings.Contains(stdout, "No connections found"),
 			"Should produce human-readable output")
 
-		t.Logf("Successfully tested human-readable output format")
+		// Verify source and destination types are displayed
+		assert.True(t,
+			strings.Contains(stdout, "[WEBHOOK]") || strings.Contains(stdout, "[webhook]"),
+			"Should display source type in output")
+		assert.True(t,
+			strings.Contains(stdout, "[CLI]") || strings.Contains(stdout, "[cli]"),
+			"Should display destination type in output")
+
+		t.Logf("Successfully tested human-readable output format with type display")
 	})
 }

test/acceptance/connection_test.go

@@ -41,14 +41,23 @@ func TestConnectionCreateAndDelete(t *testing.T) {
 		deleteConnection(t, cli, connID)
 	})
 
-	// Verify the connection was created by getting it
+	// Verify the connection was created by getting it (JSON output)
 	var conn Connection
 	err := cli.RunJSON(&conn, "connection", "get", connID)
 	require.NoError(t, err, "Should be able to get the created connection")
 	assert.Equal(t, connID, conn.ID, "Retrieved connection ID should match")
 	assert.NotEmpty(t, conn.Name, "Connection should have a name")
 	assert.NotEmpty(t, conn.Source.Name, "Connection should have a source")
+	assert.NotEmpty(t, conn.Source.Type, "Connection source should have a type")
 	assert.NotEmpty(t, conn.Destination.Name, "Connection should have a destination")
+	assert.NotEmpty(t, conn.Destination.Type, "Connection destination should have a type")
+
+	// Verify human-readable output includes type information
+	stdout := cli.RunExpectSuccess("connection", "get", connID)
+	assert.Contains(t, stdout, "Type:", "Human-readable output should include 'Type:' label")
+	assert.True(t,
+		strings.Contains(stdout, conn.Source.Type) && strings.Contains(stdout, conn.Destination.Type),
+		"Human-readable output should display both source and destination types")
 
 	t.Logf("Successfully created and retrieved connection: %s", conn.Name)
 }